home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / flockFlickrService.js < prev    next >
Encoding:
Text File  |  2007-10-18  |  103.9 KB  |  3,124 lines
  1. // vim: ts=2 sw=2 expandtab cindent
  2. //
  3. // BEGIN FLOCK GPL
  4. // 
  5. // Copyright Flock Inc. 2005-2007
  6. // http://flock.com
  7. // 
  8. // This file may be used under the terms of of the
  9. // GNU General Public License Version 2 or later (the "GPL"),
  10. // http://www.gnu.org/licenses/gpl.html
  11. // 
  12. // Software distributed under the License is distributed on an "AS IS" basis,
  13. // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14. // for the specific language governing rights and limitations under the
  15. // License.
  16. // 
  17. // END FLOCK GPL
  18.  
  19. const ENABLE_DEBUG = true; // switch to turn off slow debug code for production
  20. function DEBUG(x) { if (ENABLE_DEBUG) debug("flockFlickrService: "+x+"\n"); }
  21.  
  22. const Cc = Components.classes;
  23. const Ci = Components.interfaces;
  24. const Cr = Components.results;
  25.  
  26. Components.utils.import("resource:///modules/FlockCryptoHash.jsm");
  27. Components.utils.import("resource:///modules/FlockScheduler.jsm");
  28. Components.utils.import("resource://gre/modules/JSON.jsm");
  29.  
  30. const FLICKR_TITLE                  = "Flickr Web Service";
  31. const FLICKR_FAVICON                = "chrome://flock/content/services/flickr/favicon.png";
  32. const FLICKR_CID                    = Components.ID("{db720a5c-6315-49bf-a39f-b4d4aa5ed142}");
  33. const FLICKR_CONTRACTID             = "@flock.com/?photo-api-flickr;1";
  34. const SERVICE_ENABLED_PREF          = "flock.service.flickr.enabled";
  35. const CATEGORY_COMPONENT_NAME       = "Flickr JS Component"
  36. const CATEGORY_ENTRY_NAME           = "flickr"
  37.  
  38. const flockIError                   = Components.interfaces.flockIError;
  39. const flockIPhotoAlbum              = Components.interfaces.flockIPhotoAlbum;
  40. const flockIPhotoPerson             = Components.interfaces.flockIPhotoPerson;
  41.  
  42. const FLOCK_PHOTO_CONTRACTID        = "@flock.com/photo;1";
  43. const FLOCK_PHOTOPERSON_CONTRACTID  = "@flock.com/photo-person;1";
  44. const FLOCK_PHOTO_ALBUM_CONTRACTID  = "@flock.com/photo-album;1";
  45. const FLOCK_ERROR_CONTRACTID        = "@flock.com/error;1";
  46. const FLOCK_RDDS_CONTRACTID         = "@flock.com/rich-dnd-service;1";
  47.  
  48. const PEOPLE_PROPERTIES = "chrome://flock/locale/people/people.properties";
  49.  
  50. const FLICKR_IDENTITY_URN_PREFIX = "urn:flock:identity:flickr:";
  51. const RDFS = Components.classes["@mozilla.org/rdf/rdf-service;1"]
  52.                        .getService(Components.interfaces.nsIRDFService);
  53.  
  54. // The delay between two refreshes when the sidebar is closed (in seconds)
  55. const FLICKR_REFRESH_INTERVAL = 3600; // 60 minutes
  56. // The delay between two refreshes when the sidebar is open (in seconds)
  57. const FLICKR_SHORT_INTERVAL = 3600; // 60 minutes
  58. // The first time, only get photos not older than one week
  59. const MEDIA_INITIAL_FETCH = 7 * 24 * 3600;
  60.  
  61. var gCompTK;
  62. function getCompTK() {
  63.   if (!gCompTK) {
  64.     gCompTK = Components.classes["@flock.com/singleton;1"]
  65.                         .getService(Components.interfaces.flockISingleton)
  66.                         .getSingleton("chrome://browser/content/flock/services/common/load-compTK.js")
  67.                         .wrappedJSObject;
  68.   }
  69.   return gCompTK;
  70. }
  71.  
  72. var gFlickrAPI;
  73.  
  74. function Namespace(ns) { return function (arg) { return RDFS.GetResource (ns+arg); } }
  75. const FLRDF = Namespace("http://flock.com/rdf#");
  76.  
  77. const FLICKR_STRING_BUNDLE = "chrome://flock/locale/services/flickr.properties";
  78.  
  79. // String defaults... may be updated later through Web Detective
  80. var gStrings = {
  81.   "domains": "flickr.com,yahoo.com",
  82.   "userlogin": "http://flickr.com/signin/",
  83.   "userprofile": "http://www.flickr.com/people/%accountid%/",
  84.   "photopage": "http://www.flickr.com/photos/%accountid%/%photoid%/",
  85.   "commentsreceivedRSS": "http://api.flickr.com/services/feeds/activity.gne?id=%accountid%&format=rss_200",
  86.   "staticimage": "http://static.flickr.com/%server%/%photoid%_%secret%%size%.jpg",
  87.   "buddyicon": "http://www.flickr.com/images/buddyicon.jpg",
  88.   "staticbuddyicon": "http://static.flickr.com/%iconserver%/buddyicons/%owner%.jpg",
  89.   "nofriendavataricon": "http://static.flickr.com/0/buddyicons/%owner%.jpg",
  90.   "nomeavataricon": "http://www.flickr.com/images/buddyicon.jpg?%owner%",
  91.   "apikey": "92c2a562f0e9c2ed8dfe78f42a7734c7",
  92.   "endpoint": "http://www.flickr.com/services/rest/",
  93.   "uploadendpoint": "http://www.flickr.com/services/upload/",
  94.   "authendpoint": "http://www.flickr.com/services/auth/"
  95. };
  96.  
  97. function flickrPhoto() {
  98. }
  99.  
  100. flickrPhoto.prototype= {
  101.   id: "",
  102.   thumbnail: "",
  103.   webPageUrl: "",
  104.   midSizePhoto: "",
  105.   largeSizePhoto: "",
  106.   title: "",
  107.   username: "",
  108.   userid: "",
  109.   is_public: "true",
  110.   is_video: "false",
  111.   svcShortName: 'flickr',
  112.   buildTooltip: function( ) {
  113.     // do we have to use document from the window to ceate elements? -- ja
  114.     var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
  115.                        .getService(Components.interfaces.nsIWindowMediator);
  116.     var win = wm.getMostRecentWindow('navigator:browser');
  117.     if (!win) return null;
  118.  
  119.     var hbox = win.document.createElement('hbox');
  120.     var img = win.document.createElement('image');
  121.     img.setAttribute('src', this.icon );
  122.     hbox.appendChild(img);
  123.     var box = win.document.createElement('vbox');
  124.     box.setAttribute('style', 'max-width: 250px');
  125.     var title = win.document.createElement('label');
  126.     title.setAttribute('value', this.title );
  127.     title.setAttribute('crop', 'end');
  128.     box.appendChild(title);
  129.     var lbl = win.document.createElement('label');
  130.     lbl.setAttribute('value', this.username );
  131.     lbl.setAttribute('class', 'user');
  132.     box.appendChild(lbl);
  133.     hbox.appendChild(box)
  134.  
  135.     var vbox = win.document.createElement('vbox');
  136.     var cbox = win.document.createElement('hbox'); 
  137.     var largeImg = win.document.createElement('image');
  138.     largeImg.setAttribute('src', this.midSizePhoto);
  139.     largeImg.setAttribute('style', 'margin-bottom: 2px;');
  140.     var spacer = win.document.createElement('spacer');
  141.     spacer.setAttribute('flex', '1');
  142.     cbox.appendChild(largeImg);
  143.     cbox.appendChild(spacer);
  144.     vbox.appendChild(cbox);
  145.     vbox.appendChild(hbox);
  146.  
  147.     return vbox;
  148.   },
  149.   buildHTML: function( ) {
  150.     return '<a title="'+this.title+'" href="'+this.webPageUrl+'"><img src="'+this.midSizePhoto+'" border="0" /></a>';
  151.   },
  152.   buildLargeHTML: function( ) {
  153.     return '<a title="'+this.title+'" href="'+this.webPageUrl+'"><img src="'+this.largeSizePhoto+'" border="0" /></a>';
  154.   },
  155.   buildBBCode: function ( ) {
  156.     return '[url=' + this.webPageUrl + '][img]'+ this.largeSizePhoto +'[/img][/url]';
  157.   },
  158.   QueryInterface: function(iid) {
  159.     if (!iid.equals(Components.interfaces.nsISupports) &&
  160.         !iid.equals(Components.interfaces.flockIPhoto)) {
  161.       throw Components.results.NS_ERROR_NO_INTERFACE;
  162.     }
  163.     return this;
  164.   }
  165. };
  166.  
  167.  
  168. // ====================================================
  169. // ========== BEGIN General helper functions ==========
  170. // ====================================================
  171.  
  172. function loadSubScript(spec)
  173. {
  174.   var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
  175.               .getService(Components.interfaces.mozIJSSubScriptLoader);
  176.   var context = {};
  177.   loader.loadSubScript(spec, context);
  178.   return context;
  179. }
  180.  
  181. function loadLibraryFromSpec(aSpec)
  182. {
  183.   var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
  184.                          .getService(Components.interfaces.mozIJSSubScriptLoader);
  185.   loader.loadSubScript(aSpec);
  186. }
  187.  
  188. loadSubScript("chrome://browser/content/utilityOverlay.js");
  189.  
  190. loadLibraryFromSpec("chrome://flock/content/common/flocksafe.js");
  191. loadLibraryFromSpec("chrome://browser/content/flock/photo/photoAPI.js");
  192.  
  193. function flock_flickrBuildPhotoUrl(server, id, secret, size)
  194. {
  195.   var convertedSize = "";
  196.   switch (size) {
  197.     case "square": convertedSize = "_s"; break;
  198.     case "thumbnail": convertedSize = "_t"; break;
  199.     case "small": convertedSize = "_m"; break;
  200.     case "medium": convertedSize = "_d"; break;
  201.     case "large": convertedSize = "_b"; break;
  202.     case "original": convertedSize = "_o"; break;
  203.     default: convertedSize = "";
  204.   }
  205.   return gStrings["staticimage"].replace("%server%", server)
  206.                                 .replace("%photoid%", id)
  207.                                 .replace("%secret%", secret)
  208.                                 .replace("%size%", convertedSize);
  209. }
  210.  
  211. function _getIdentityUrn(aAccountId, aUid) {
  212.   var result = FLICKR_IDENTITY_URN_PREFIX
  213.              + aAccountId + ":"
  214.              + aUid;
  215.   return result;
  216. }
  217.  
  218. function flock_flickrBuildPageUrl(aUserID, aPhotoID) {
  219.   return gStrings["photopage"].replace("%accountid%", aUserID).replace("%photoid%", aPhotoID);
  220. }
  221.  
  222. // refresh the mediabar if it is open and contains private media
  223. function flock_refreshMediabarIfHasPrivate() {
  224.   var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
  225.                      .getService(Components.interfaces.nsIWindowMediator);
  226.   var win = wm.getMostRecentWindow("navigator:browser");
  227.   // if the mediabar is open
  228.   if (win &&
  229.       win.document.getElementById("mediabar") &&
  230.       win.document.getElementById("mediabar").getAttribute("hidden") != "true" &&
  231.       win.TopbarJSCtx().gPhotoDrawer &&
  232.       win.TopbarJSCtx().gPhotoDrawer.mHasPrivateMedia)
  233.   {
  234.       win.TopbarJSCtx().gPhotoDrawer.refreshView();
  235.   }
  236. }
  237.  
  238. // ===============================================
  239. // ========== BEGIN flickrService class ==========
  240. // ===============================================
  241.  
  242. function flickrService()
  243. {
  244.   this.obs = Components.classes["@mozilla.org/observer-service;1"]
  245.                        .getService(Components.interfaces.nsIObserverService);
  246.  
  247.   this.acUtils = Components.classes["@flock.com/account-utils;1"]
  248.                            .getService(Components.interfaces.flockIAccountUtils);
  249.  
  250.   this.url = "http://www.flickr.com";
  251.   this.mIsInitialized = false;
  252.   this._ctk = {
  253.     interfaces: [
  254.       "nsISupports",
  255.       "nsIClassInfo",
  256.       "nsISupportsCString",
  257.       "nsIObserver",
  258.       "flockIPollingService",
  259.       "flockIWebService",
  260.       "flockIAuthenticateNewAccount",
  261.       "flockIManageableWebService",
  262.       "flockIMediaWebService",
  263.       "flockISocialWebService",
  264.       "flockIRichContentDropHandler"
  265.     ],
  266.     shortName: "flickr",
  267.     fullName: "Flickr",
  268.     description: FLICKR_TITLE,
  269.     favicon: FLICKR_FAVICON,
  270.     CID: FLICKR_CID,
  271.     contractID: FLICKR_CONTRACTID,
  272.     accountClass: flickrAccount,
  273.     needPassword: false
  274.   };
  275.   this._logger = Cc['@flock.com/logger;1'].createInstance(Ci.flockILogger);
  276.   this._logger.init('flickr');
  277.   this._profiler = Cc["@flock.com/profiler;1"].getService(Ci.flockIProfiler);
  278.  
  279.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  280.           .getService(Ci.nsIStringBundleService);
  281.   var bundle = sbs.createBundle(FLICKR_STRING_BUNDLE);
  282.  
  283.   this._channels = {
  284.     "special:recent": {
  285.       title: bundle.GetStringFromName("flock.flickr.title.recent"),
  286.       supportsSearch: false
  287.     },
  288.     "special:interestingness": {
  289.       title: bundle.GetStringFromName("flock.flickr.title.interestingness"),
  290.       supportsSearch: true
  291.     }
  292.   };
  293.   this.init();
  294. }
  295.  
  296. flickrService.prototype.serviceName = "Flickr";
  297. flickrService.prototype.shortName = "flickr";
  298.  
  299. flickrService.prototype.handleInfoResult = function(aXML) {
  300.   var photo = aXML.getElementsByTagName("photo")[0];
  301.   var owner = aXML.getElementsByTagName("owner")[0];
  302.   var visibility = aXML.getElementsByTagName("visibility")[0];
  303.   var title = aXML.getElementsByTagName("title")[0].firstChild.nodeValue;
  304.   var dates =  aXML.getElementsByTagName("dates")[0];
  305.   var id = photo.getAttribute("id");
  306.   var server = photo.getAttribute("server");
  307.   var secret = photo.getAttribute("secret");
  308.   var lastUpdate = dates.lastupdate;
  309.   var uploadDate = dates.posted;
  310.   var square_url = flock_flickrBuildPhotoUrl(server,id,secret,'square');
  311.   var small_url = flock_flickrBuildPhotoUrl(server,id,secret,'small');
  312.   var med_url = flock_flickrBuildPhotoUrl(server,id,secret,'medium');
  313.   var page_url = flock_flickrBuildPageUrl(owner.getAttribute('nsid'),id);
  314.   var icon_server = photo.getAttribute("iconserver");
  315.   var newPhoto = new flickrPhoto();
  316.   newPhoto.webPageUrl = page_url;
  317.   newPhoto.thumbnail = square_url;
  318.   newPhoto.midSizePhoto = small_url;
  319.   newPhoto.largeSizePhoto = med_url;
  320.   newPhoto.username = owner.getAttribute('username');
  321.   newPhoto.title = title;
  322.   newPhoto.id = id;
  323.   newPhoto.lastUpdate = lastUpdate;
  324.   newPhoto.uploadDate = parseInt(uploadDate)*1000;
  325.   if (icon_server == '1') {
  326.     newPhoto.icon = gStrings["buddyicon"];
  327.   }
  328.   else {
  329.     newPhoto.icon = gStrings["staticbuddyicon"]
  330.                     .replace("%iconserver%", icon_server)
  331.                     .replace("%owner%", owner);
  332.   }
  333.   var ispublic = visibility.getAttribute("ispublic");
  334.   if (ispublic =="1") ispublic = "true";
  335.   else ispublic = "false";
  336.   newPhoto.is_public = ispublic;
  337.   newPhoto.is_video = false;
  338.   return newPhoto;
  339. }
  340.  
  341. flickrService.prototype.handlePhotosResult =
  342. function (aXML, aUserid)
  343. {
  344.   var rval = [];
  345.   var photoList = aXML.getElementsByTagName("photo");
  346.   for (var i = 0; i < photoList.length; i++) {
  347.     var photo = photoList[i];
  348.  
  349.     var id = photo.getAttribute("id");
  350.     var server = photo.getAttribute("server");
  351.     var secret = photo.getAttribute("secret");
  352.     var title = photo.getAttribute("title");
  353.     var owner = photo.getAttribute("owner");
  354.     if (!owner) owner = aUserid;
  355.     var owner_name = photo.getAttribute("ownername");
  356.     var date_upload = photo.getAttribute("dateupload");
  357.     var date_added = photo.getAttribute("dateadded");
  358.     
  359.     var icon_server = photo.getAttribute("iconserver");
  360.     var square_url = flock_flickrBuildPhotoUrl(server,id,secret,'square');
  361.     var small_url = flock_flickrBuildPhotoUrl(server,id,secret,'small');
  362.     var med_url = flock_flickrBuildPhotoUrl(server,id,secret,'medium');
  363.     var page_url = flock_flickrBuildPageUrl(owner,id);
  364.     var newPhoto = new flickrPhoto();
  365.     newPhoto.webPageUrl = page_url;
  366.     newPhoto.thumbnail = square_url;
  367.     newPhoto.midSizePhoto = small_url;
  368.     newPhoto.largeSizePhoto = med_url;
  369.     newPhoto.username = owner_name;
  370.     newPhoto.userid = owner;
  371.     newPhoto.title = title;
  372.     newPhoto.id = id;
  373.     if (icon_server == '1') {
  374.       newPhoto.icon = gStrings["buddyicon"];
  375.     }
  376.     else {
  377.       newPhoto.icon = gStrings["staticbuddyicon"]
  378.                       .replace("%iconserver%", icon_server)
  379.                       .replace("%owner%", owner);
  380.     }
  381.     newPhoto.uploadDate = parseInt((date_added) ? date_added : date_upload)*1000;
  382.  
  383.     // if the photo result set doesn't return back the ispublic
  384.     // attribute, we assume that the server is returning only
  385.     // public photos back in the response
  386.     if (photo.hasAttribute("ispublic")) {
  387.       var ispublic = photo.getAttribute("ispublic");
  388.       if (ispublic =="1") ispublic = "true";
  389.       else ispublic = "false";
  390.     } else {
  391.       ispublic = "true";
  392.     }
  393.  
  394.     newPhoto.is_public = ispublic;
  395.     newPhoto.is_video = false;
  396.  
  397.     rval.push(newPhoto);
  398.   }
  399.   return rval;
  400. }
  401.  
  402. flickrService.prototype.getPhotoFromRDFNode =
  403. function (aRDFId)
  404. {
  405.   var newPhoto = new flickrPhoto();
  406.   var coopPhoto = this.faves_coop.get(aRDFId);
  407.   newPhoto.webPageUrl = coopPhoto.URL;
  408.   newPhoto.thumbnail = coopPhoto.thumbnail;
  409.   newPhoto.midSizePhoto = coopPhoto.midSizePhoto;
  410.   newPhoto.largeSizePhoto = coopPhoto.largeSizePhoto;
  411.   newPhoto.username = coopPhoto.username;
  412.   newPhoto.userid = coopPhoto.userid;
  413.   newPhoto.title = coopPhoto.name;
  414.   newPhoto.id = coopPhoto.photoid;
  415.   newPhoto.icon = coopPhoto.favicon;
  416.   newPhoto.uploadDate = coopPhoto.datevalue;
  417.   newPhoto.is_public = coopPhoto.is_public;
  418.   newPhoto.is_video = coopPhoto.is_video;
  419.   return newPhoto;
  420. }
  421.  
  422. flickrService.prototype.handleContactsResult =
  423. function (aXML)
  424. {
  425.   var rval = [];
  426.   var contactList = aXML.getElementsByTagName("contact");
  427.   for (var i = 0; i < contactList.length; i++) {
  428.     var contact = contactList[i];
  429.     var nsid = contact.getAttribute("nsid");
  430.     var username = contact.getAttribute("username");
  431.     var fullname = contact.getAttribute("fullname");
  432.     var family = contact.getAttribute("family");
  433.     var friend = contact.getAttribute("friend");
  434.     var icon_server = contact.getAttribute("iconserver");
  435.  
  436.     if (true || family == "1" || friend == "1") {
  437.       this._logger.debug(".handleContactsResult(): id=" + nsid
  438.                         + " username=" + username
  439.                         + " family=" + family
  440.                         + " friend=" + friend);
  441.  
  442.       var newContact = {};
  443.       newContact.id = nsid;
  444.       newContact.username = username;
  445.       newContact.fullname = username;
  446.       
  447.       // If friend has no avatar, set it to null here and people sidebar
  448.       // code will fill it with the standard Flock no avatar image.
  449.       var noAvatarUrl = gStrings["nofriendavataricon"].replace("%owner%", nsid);
  450.       var avatarUrl = gStrings["staticbuddyicon"]
  451.                              .replace("%iconserver%", icon_server)
  452.                              .replace("%owner%", nsid);
  453.       if (noAvatarUrl == avatarUrl) {
  454.         newContact.avatarUrl = null;
  455.       } else {
  456.         newContact.avatarUrl = avatarUrl;
  457.       }
  458.  
  459.       rval[nsid] = newContact;
  460.     }
  461.   }
  462.   return rval;
  463. }
  464.  
  465. flickrService.prototype.handleAlbumsResult =
  466. function (aXML)
  467. {
  468.   var rval = [];
  469.   var photosetList = aXML.getElementsByTagName("photoset");
  470.   var titleList = aXML.getElementsByTagName("title");
  471.   for (var i = 0; i < photosetList.length; i++) {
  472.     var id = photosetList[i].getAttribute("id");
  473.     var title = titleList[i].firstChild.nodeValue;
  474.  
  475.     var newAlbum = Components.classes[FLOCK_PHOTO_ALBUM_CONTRACTID]
  476.                              .createInstance(flockIPhotoAlbum);
  477.     newAlbum.id = id;
  478.     newAlbum.title = title;
  479.  
  480.     rval.push(newAlbum);
  481.   }
  482.   return rval;
  483. }
  484.  
  485. flickrService.prototype.getContacts =
  486. function flickrService_getContacts(aListener)
  487. {
  488.   this._logger.info(".getContacts(...)");
  489.   var inst = this;
  490.   var myListener = {
  491.     onResult: function (aXML) {
  492.       var peeps = inst.handleContactsResult(aXML);
  493.       var result = {
  494.         wrappedJS: peeps
  495.       }
  496.       aListener.onGetContactsResult(result);
  497.     },
  498.     onError: function (aError) {
  499.       aListener.onError(aError);
  500.     }
  501.   }
  502.   var params = {};
  503.   var dict = params2Dictionary(params);
  504.   this.authenticatedCall(myListener, "flickr.contacts.getList", dict);
  505. }
  506.  
  507.  
  508. flickrService.prototype.getPhoto =
  509. function (aListener, aID)
  510. {
  511.   var inst = this;
  512.   var myListener = {
  513.     onResult: function (aXML) {
  514.       var photo = inst.handleInfoResult(aXML);
  515.       aListener.onGetPhoto(photo);
  516.     },
  517.     onError: function (aError) {
  518.       aListener.onError(aError);
  519.     }
  520.   }
  521.   var params = {};
  522.   params.photo_id = aID;
  523.   var dict = params2Dictionary(params);
  524.   if (this.getAuthUser()) {
  525.     this.authenticatedCall(myListener, "flickr.photos.getInfo", dict);
  526.   } else {
  527.     this.call(myListener, "flickr.photos.getInfo", dict);
  528.   }
  529. }
  530.  
  531. flickrService.prototype.createAlbum =
  532. function (aListener, aTitle)
  533. {
  534.   // trim white space from front and end of string
  535.   aTitle = aTitle.replace(/^\s+|\s+$/g, "");
  536.   if (aTitle) {
  537.     var newAlbum = Components.classes[FLOCK_PHOTO_ALBUM_CONTRACTID]
  538.                              .createInstance(flockIPhotoAlbum);
  539.     newAlbum.title = aTitle;
  540.     var date = new Date();  //hopefully this won't collide with an actual id!
  541.     newAlbum.id = date.getTime();
  542.     this.api.fakeAlbums[newAlbum.id] = newAlbum;
  543.     aListener.onCreateAlbum(newAlbum);
  544.   } else {
  545.     var error = Components.classes[FLOCK_ERROR_CONTRACTID].createInstance(flockIError);
  546.     error.errorCode = error.PHOTOSERVICE_EMPTY_ALBUMNAME;
  547.     aListener.onError(error);
  548.   }
  549. }
  550.  
  551. flickrService.prototype.getAlbums =
  552. function flickrService_getAlbums(aListener, aUsername)
  553. {
  554.   var inst = this;
  555.   var myListener = {
  556.     onResult: function (aXML) {
  557.       try {
  558.       var rval = inst.handleAlbumsResult(aXML);
  559.       var enum_ = {
  560.         hasMoreElements: function() {
  561.           return (rval.length>0);
  562.         },
  563.         getNext: function() {
  564.           return rval.shift();
  565.         }
  566.       }
  567.       aListener.onGetAlbumsResult(enum_);
  568.       } catch(e) {
  569.         aListener.onError(null);
  570.       }
  571.     },
  572.     onError: function (aXML) {
  573.       aListener.onError(aXML);
  574.     }
  575.   }
  576.   var params = {};
  577.   if (aUsername) {
  578.     params.user_id  = aUsername;
  579.   }
  580.   var dict = params2Dictionary(params);
  581.   if (this.getAuthUser()) {
  582.     this.authenticatedCall(myListener, "flickr.photosets.getList", dict);
  583.   } else {
  584.     this.call(myListener, "flickr.photosets.getList", dict);
  585.   }
  586. }
  587.  
  588. flickrService.prototype.getAccountStatus =
  589. function flickrService_getAccountStatus(aListener)
  590. {
  591.   var inst = this;
  592.   var myListener = {
  593.     onResult:function (aXML) {
  594.       try {
  595.         inst._logger.info('we got a result for account status...');
  596.         var result = Cc["@mozilla.org/hash-property-bag;1"]
  597.                      .createInstance(Ci.nsIWritablePropertyBag2);
  598.         var username = aXML.getElementsByTagName('username')[0].firstChild.nodeValue;
  599.         var bandwidth = aXML.getElementsByTagName('bandwidth')[0];
  600.         var maxFileSize = aXML.getElementsByTagName('filesize')[0];
  601.         var isPro = aXML.getElementsByTagName('user')[0].getAttribute('ispro');
  602.         var maxSpace = bandwidth.getAttribute("max");
  603.         var usedSpace = bandwidth.getAttribute("used");
  604.         result.setPropertyAsAString("username", username);
  605.         result.setPropertyAsAString("maxSpace", maxSpace);
  606.         result.setPropertyAsAString("usedSpace", usedSpace);
  607.         result.setPropertyAsAString("maxFileSize", maxFileSize);
  608.         result.setPropertyAsAString("usageUnits", "bytes");
  609.         result.setPropertyAsBool("isPremium", (isPro == "1"));
  610.         aListener.onSuccess(result, "");
  611.       } catch (ex) {
  612.         inst._logger.info('getaccountstatus error >>>>>>>>>>>>>>>>>>>>' + ex);
  613.       }
  614.     },
  615.     onError: function (aError) {
  616.       aListener.onError(aError);
  617.     }
  618.   }
  619.   var params = {};
  620.   var dict = params2Dictionary(params);
  621.   this.authenticatedCall(myListener, "flickr.people.getUploadStatus", dict);
  622. }
  623.  
  624. flickrService.prototype.getContactsPhotos =
  625. function flickrService_getContactsPhotos(aListener)
  626. {
  627.   // return; // XXX TODO FIXME (JMC): Save me from contacts' photos hanging my browser!
  628.   var inst = this;
  629.   var myListener = {
  630.     onResult: function (aXML) {
  631.       var rval = inst.handlePhotosResult(aXML);
  632.       var enum_ = {
  633.         hasMoreElements: function() {
  634.           return (rval.length>0);
  635.         },
  636.         getNext: function() {
  637.           return rval.shift();
  638.         }
  639.       }
  640.       aListener.onSearchResult(enum_);
  641.     },
  642.     onError: function (aXML) {
  643.       aListener.onError(null);
  644.     }
  645.   }
  646.   var params = {};
  647.   params.single_photo = "1";
  648.   params.include_self = "1";
  649.   params.extras = "owner_name,license,date_upload,icon_server";
  650.   var dict = params2Dictionary(params);
  651.   this.authenticatedCall(myListener, "flickr.photos.getContactsPhotos", dict);
  652. }
  653.  
  654. flickrService.prototype.getMostRecentPhotoForList =
  655. function flickrService_getMostRecentPhotoForList(aListener, aEnumerator)
  656. {
  657.   var mg = new MultiGetter();
  658.   mg.init(this, aListener, aEnumerator);
  659. }
  660.  
  661. flickrService.prototype.findByUsername =
  662. function flickrService_findByUsername(aListener, aUsername)
  663. {
  664.   var inst = this;
  665.   var userListener = function(aListener) {
  666.     this.mListener = aListener;
  667.   }
  668.   userListener.prototype.onGetInfo = function (aPerson) {
  669.     this.mListener.onFindByUsernameResult(aPerson);
  670.   }
  671.   userListener.prototype.onError = function (aError) {
  672.     inst._logger.info(aError);
  673.     this.mListener.onError(aError);
  674.   }
  675.   var myListener = {
  676.     onResult: function (aXML) {
  677.       var user = aXML.getElementsByTagName("user")[0];
  678.       var id = user.getAttribute("id");
  679.       inst.people_getInfo(new userListener(aListener), id);
  680.     },
  681.     onError: function (aXML) {
  682.       aListener.onError(aXML);
  683.     }
  684.   }
  685.   var params = {};
  686.   params.username = aUsername;
  687.   var dict = params2Dictionary(params);
  688.   this.call(myListener, "flickr.people.findByUsername", dict);
  689. }
  690.  
  691.  
  692. flickrService.prototype.lookupUser =
  693. function (aListener, aURL)
  694. {
  695.   var inst = this;
  696.   var myListener = {
  697.     onResult: function (aXML) {
  698.       var newUserObj = Components.classes[FLOCK_PHOTOPERSON_CONTRACTID]
  699.                                  .createInstance(flockIPhotoPerson);
  700.       var user = aXML.getElementsByTagName("user")[0];
  701.       newUserObj.service = inst;
  702.       newUserObj.id = user.getAttribute("id");
  703.       newUserObj.username = user.getElementsByTagName("username")[0].childNodes[0].nodeValue;
  704.       newUserObj.fullname = newUserObj.username;
  705.       aListener.onLookupUser(newUserObj);
  706.     },
  707.     onError: function (aXML) {
  708.       aListener.onError(aXML);
  709.     }
  710.   }
  711.   var params = {};
  712.   params.url = aURL;
  713.   var dict = params2Dictionary(params);
  714.   this.call(myListener, "flickr.urls.lookupUser", dict);
  715. }
  716.  
  717. flickrService.prototype.people_getInfo =
  718. function (aListener, aUserId)
  719. {
  720.   var inst = this;
  721.   var myListener = {
  722.     onResult: function (aXML) {
  723.       var newUserObj = Components.classes[FLOCK_PHOTOPERSON_CONTRACTID].createInstance(flockIPhotoPerson);
  724.       var person = aXML.getElementsByTagName("person")[0];
  725.       var icon_server = person.getAttribute("iconserver");
  726.       var count = person.getElementsByTagName("photos")[0].getElementsByTagName("count")[0].firstChild.nodeValue;
  727.       newUserObj.service = inst;
  728.       newUserObj.id = person.getAttribute("id");
  729.       newUserObj.username = person.getElementsByTagName('username')[0].firstChild.nodeValue + '';
  730.       newUserObj.fullname = newUserObj.username;
  731.       newUserObj.avatarUrl = gStrings["staticbuddyicon"]
  732.                              .replace("%iconserver%", icon_server)
  733.                              .replace("%owner%", newUserObj.id);
  734.       newUserObj.photoCount = parseInt(count);
  735.       aListener.onGetInfo(newUserObj);
  736.     },
  737.     onError: function (aXML) {
  738.       aListener.onError(aXML);
  739.     }
  740.   }
  741.   var params = {};
  742.   params.user_id = aUserId;
  743.   var dict = params2Dictionary(params);
  744.   this.call(myListener, "flickr.people.getInfo", dict);
  745. }
  746.  
  747. flickrService.prototype.queryChannel =
  748. function flickrService_queryChannel(aListener, aQueryString, aCount, aPage)
  749. {
  750.   var aQuery = new queryHelper(aQueryString);
  751.   // return; // XXX TODO FIXME: This is killing performance!
  752.   var inst=this;
  753.   var myListener = {
  754.     onResult: function (aXML) {
  755.       var rval = inst.handlePhotosResult(aXML);
  756.       var enum_ = {
  757.         hasMoreElements: function() {
  758.           return (rval.length>0);
  759.         },
  760.         getNext: function() {
  761.           return rval.shift();
  762.         }
  763.       }
  764.       aListener.onSearchResult(enum_);
  765.     },
  766.     onError: function (aError) {
  767.       aListener.onError(aError);
  768.     }
  769.   }
  770.  
  771.   var params = {
  772.     per_page: aCount,
  773.     page: aPage,
  774.     extras: "owner_name,icon_server,date_upload,license"
  775.   };
  776.  
  777.   if (aQuery.getKey('special') == 'recent') {
  778.     if (aQuery.hasKey('search')) {
  779.       params.text = aQuery.getKey('search');
  780.       var dict = params2Dictionary(params);
  781.       this.call(myListener, "flickr.photos.search", dict);
  782.     } else {
  783.       var dict = params2Dictionary(params);
  784.       this.call(myListener, "flickr.photos.getRecent", dict)
  785.     }
  786.   }
  787.  
  788.   if (aQuery.getKey("special") == 'interestingness') {
  789.     if (aQuery.hasKey('search')) {
  790.       params.text = aQuery.getKey('search');
  791.       params.sort = 'interestingness-desc';
  792.       var dict = params2Dictionary(params);
  793.       this.call(myListener, "flickr.photos.search", dict);
  794.     } else {
  795.       var dict = params2Dictionary(params);
  796.       this.call(myListener, "flickr.interestingness.getList", dict)
  797.     }
  798.   }
  799.  
  800.   if (aQuery.hasKey('search')) {
  801.      aText = aQuery.getKey('search');
  802.      if (aText && aText.length) {
  803.        params.text = aText;
  804.        var dict = params2Dictionary(params);
  805.        this.call(myListener, "flickr.photos.search", dict);
  806.      }
  807.    }
  808. }
  809.  
  810. flickrService.prototype.poolSearch =
  811. function flickrService_poolSearch(aListener, aQueryString, aCount, aPage)
  812. {
  813.   var aQuery = new queryHelper(aQueryString);
  814.   var inst = this;
  815.   var myListener = {
  816.     onResult: function (aXML) {
  817.       var rval = inst.handlePhotosResult(aXML);
  818.       var enum_ = {
  819.         hasMoreElements: function() {
  820.           return (rval.length>0);
  821.         },
  822.         getNext: function() {
  823.           return rval.shift();
  824.         }
  825.       }
  826.       aListener.onSearchResult(enum_);
  827.     },
  828.     onError: function (aError) {
  829.       aListener.onError(aError);
  830.     }
  831.   }
  832.  
  833. /*
  834.   var aText;
  835.  
  836.   if (aQuery.split('?').length > 1) {
  837.     aText = aQuery.split('?')[1];
  838.     aQuery = aQuery.split('?')[0];
  839.   }
  840.  
  841.   aQuery = aQuery.split(':')[1]
  842.   */
  843.  
  844.   var params = {
  845.     group_id: aQuery.pool,
  846.     per_page: aCount,
  847.     page: aPage,
  848.     extras: "owner_name,icon_server,date_upload,license"
  849.   };
  850.  
  851.   if (aQuery.search) {
  852.     params.tags = aQuery.search;
  853.     var dict = params2Dictionary(params);
  854.     this.call(myListener, "flickr.groups.pools.getPhotos", dict);
  855.   } else {
  856.     var dict = params2Dictionary(params);
  857.     this.call(myListener, "flickr.groups.pools.getPhotos", dict)
  858.   }
  859. }
  860.  
  861. flickrService.prototype.search =
  862. function flickrService_search(aListener, aQueryString, aCount, aPage)
  863. {
  864.   var aQuery = new queryHelper(aQueryString);
  865.   if (aQuery.pool) {
  866.       this.poolSearch(aListener, aQueryString, aCount, aPage);
  867.       return;
  868.     }
  869.   if (!aQuery.user) {
  870.       this.queryChannel(aListener, aQueryString, aCount, aPage);
  871.       return;
  872.   }
  873.   var aUserid = aQuery.user;
  874.   var inst = this;
  875.   var myListener = {
  876.     onResult: function (aXML) {
  877.       var rval = inst.handlePhotosResult(aXML, aUserid);
  878.       var enum_ = {
  879.         hasMoreElements: function() {
  880.           return (rval.length>0);
  881.         },
  882.         getNext: function() {
  883.           return rval.shift();
  884.         }
  885.       }
  886.       aListener.onSearchResult(enum_);
  887.     },
  888.     onError: function (aError) {
  889.       aListener.onError(aError);
  890.     }
  891.   }
  892.   // Flickr return the photo in the reverse side when calling flickr.photosets.getPhotos!
  893.   // So we need to enumerate backward :-/
  894.   var myPhotosetListener = {
  895.     onResult: function (aXML) {
  896.       var rval = inst.handlePhotosResult(aXML, aUserid);
  897.       var enum_ = {
  898.         hasMoreElements: function() {
  899.           return (rval.length>0);
  900.         },
  901.         getNext: function() {
  902.           return rval.pop();
  903.         }
  904.       }
  905.       aListener.onSearchResult(enum_);
  906.     },
  907.     onError: function (aError) {
  908.       aListener.onError(aError);
  909.     }
  910.   }
  911.  
  912.   var params = {};
  913.   if (aUserid && aUserid.length) params.user_id = aUserid;
  914.   params.per_page = aCount;
  915.   params.page = aPage;
  916.  
  917.   if (aQuery.search) params.text = aQuery.search;
  918.  
  919.   params.tag_mode = "all";
  920.   params.extras = "owner_name,license,date_upload,icon_server";
  921.   if (aQuery.album) {
  922.     params.photoset_id = aQuery.album;
  923.   }
  924.  
  925.   var dict = params2Dictionary(params);
  926.   if (params.photoset_id) {
  927.     if (aPage > 1) return; // this is because the flickr call doesn't support pagination [bug 4770]
  928.     dict = params2Dictionary(params);
  929.     if (this.getAuthUser())
  930.       this.authenticatedCall(myPhotosetListener, "flickr.photosets.getPhotos", dict);
  931.     else
  932.       this.call(myPhotosetListener, "flickr.photosets.getPhotos", dict);
  933.   } else if (params.user_id || params.text) {
  934.     if (this.getAuthPerson()) {
  935.       this.authenticatedCall(myListener, "flickr.photos.search", dict);
  936.     }
  937.     else {
  938.       this.call(myListener, "flickr.photos.search", dict);
  939.     }
  940.   }
  941. }
  942.  
  943. flickrService.prototype.supportsSearch =
  944. function flickrService_supportsSearch( aQueryString ) {
  945.   var aQuery = new queryHelper(aQueryString);
  946.  
  947.   if (aQuery.special) {
  948.     var channel = this._channels["special:" + aQuery.special];
  949.     if (channel) {
  950.       return channel.supportsSearch;
  951.     }
  952.   }
  953.  
  954.   if (aQuery.album) {
  955.     return false;
  956.   }
  957.   if (aQuery.user) {
  958.     return true;
  959.   }
  960.   if (aQuery.search) {
  961.     return false;
  962.   }
  963.   return false;
  964. }
  965.  
  966. flickrService.prototype.mSupportsTitle = true;
  967. flickrService.prototype.mSupportsTags = true;
  968. flickrService.prototype.mSupportsContacts = true;
  969. flickrService.prototype.mSupportsPrivacy = true;
  970.  
  971. flickrService.prototype.supportsFeature =
  972. function flickrService_supportsFeature(aFeature)
  973. {
  974.   var supports = {};
  975.   supports.tags = true;
  976.   supports.title = true;
  977.   supports.fileName = false;
  978.   supports.contacts = true;
  979.   supports.privacy = true;
  980.   supports.albumCreation = true;
  981.   return (supports[aFeature] == true);
  982. }
  983.  
  984. flickrService.prototype.init =
  985. function flickrService_init()
  986. {
  987.   // Prevent re-entry
  988.   if (this.mIsInitialized) return;
  989.   this.mIsInitialized = true;
  990.  
  991.   this._logger.info(".init()");
  992.   var evtID = this._profiler.profileEventStart("flickr-init");
  993.  
  994.   // Determine whether this service has been disabled, and unregister if so.
  995.   this.prefService = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
  996.   if ( this.prefService.getPrefType(SERVICE_ENABLED_PREF) &&
  997.        !this.prefService.getBoolPref(SERVICE_ENABLED_PREF) )
  998.   {
  999.     this._logger.info("Pref "+SERVICE_ENABLED_PREF+" set to FALSE... not initializing.");
  1000.     var catMgr = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager);
  1001.     catMgr.deleteCategoryEntry("wsm-startup", CATEGORY_COMPONENT_NAME, true);
  1002.     catMgr.deleteCategoryEntry("flockWebService", CATEGORY_ENTRY_NAME, true);
  1003.     catMgr.deleteCategoryEntry("flockMediaProvider", CATEGORY_ENTRY_NAME, true);
  1004.     return;
  1005.   }
  1006.  
  1007.   if (!gFlickrAPI) {
  1008.     gFlickrAPI = new FlickrAPI();
  1009.   }
  1010.   this.api = gFlickrAPI;
  1011.   this.api.svc = this;
  1012.   var inst = this;
  1013.  
  1014.   this.faves_coop = Components.classes["@flock.com/singleton;1"]
  1015.                               .getService(Components.interfaces.flockISingleton)
  1016.                               .getSingleton("chrome://flock/content/common/load-faves-coop.js")
  1017.                               .wrappedJSObject;
  1018.  
  1019.   this.urn = "urn:flickr:service";
  1020.   this.svcCoopObj = new this.faves_coop.Service(
  1021.     this.urn,
  1022.     {
  1023.       name: "flickr",
  1024.       desc: "The Flickr Service",
  1025.       contactLabel: 'Contacts'
  1026.     }
  1027.   );
  1028.   this.svcCoopObj.serviceId = FLICKR_CONTRACTID;
  1029.  
  1030.   // Load Web Detective file
  1031.   this.webDetective = this.acUtils.useWebDetective("flickr.xml");
  1032.   for (var s in gStrings) {
  1033.     gStrings[s] = this.webDetective.getString("flickr", s, gStrings[s]);
  1034.   }
  1035.   this.svcCoopObj.domains = gStrings["domains"];
  1036.   this.svcCoopObj.loginURL = gStrings["userlogin"];
  1037.  
  1038.   // Update auth states
  1039.   try {
  1040.     if (this.webDetective.detectCookies("flickr", "loggedout", null)) {
  1041.       this.acUtils.markAllAccountsAsLoggedOut(FLICKR_CONTRACTID);
  1042.       this.api.logout();
  1043.     }
  1044.   } catch (ex) {
  1045.     this._logger.error("ERROR updating auth states for Flickr: "+ex);
  1046.   }
  1047.  
  1048.   // On browser restart if a Flickr coop account is still marked as
  1049.   // authenticated we also need to reauth the api. We do this by calling
  1050.   // login() on the xpcom account obj. However, we have to wait while
  1051.   // the Flickr service is finished constructing itself.
  1052.   var reloginCallback = {
  1053.     notify: function reloginCallback_notify(aTimer) {
  1054.       inst._logger.info("reloginCallback.notify()")
  1055.       var acctURN = inst.acUtils
  1056.                         .getFirstAuthenticatedAccountForService(inst.svcCoopObj
  1057.                                                                     .serviceId);
  1058.  
  1059.       if (acctURN) {
  1060.         var account = inst.getAccount(acctURN);
  1061.         if (account) {
  1062.           var reloginListener = {
  1063.             onSuccess: function reloginListener_onSuccess(aSubject, aTopic) {
  1064.               inst._logger.info(".init(): reloginListener: onSuccess()");
  1065.             },
  1066.             onError: function reloginListener_onError(aError) {
  1067.               inst._logger.info(".init(): reloginListener: onError()");
  1068.               inst.faves_coop.get(acctURN).isAuthenticated = false;
  1069.             }
  1070.           };
  1071.           account.login(reloginListener);
  1072.         }
  1073.       }
  1074.     }
  1075.   };
  1076.   var reloginTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  1077.   reloginTimer.initWithCallback(reloginCallback, 100, Ci.nsITimer.TYPE_ONE_SHOT);
  1078.  
  1079.   var timerFunc = {
  1080.     inProgress: false,
  1081.     count: 0,
  1082.     observe: function(subject, topic, state) {
  1083.       //if (topic == 'nsPref:changed' && state == FLICKR_TOKEN_PREF_ID) {
  1084.       //  var oldToken = flock_getCharPref(FLICKR_TOKEN_PREF_ID);
  1085.       //  if (oldToken && oldToken.length && !inst.api.isLoggedIn()) {
  1086.       //    this.inProgress = true;
  1087.       //    inst.api.checkToken(this, oldToken);
  1088.       //  }
  1089.       //}
  1090.     },
  1091.     notify: function(aTimer) {
  1092.       if (this.inProgress) return;
  1093.       if (inst.api.isLoggedIn()) {
  1094.         inst.api.processPendingUploadTickets();
  1095.         inst.api.processPendingAlbumAdditions();
  1096.       }
  1097.     },
  1098.     onResult: function(aXML) {
  1099.       this.inProgress = false;
  1100.     },
  1101.     onSuccess: function(aXML) {
  1102.       this.inProgress = false;
  1103.     },
  1104.     onError: function(aError) {
  1105.       inst.logout();
  1106.       this.inProgress = false;
  1107.     }
  1108.   }
  1109.   //timerFunc.observe(null, 'nsPref:changed', FLICKR_TOKEN_PREF_ID);
  1110.   timerFunc.notify();
  1111.   //var prefs = Components.classes['@mozilla.org/preferences-service;1']
  1112.   //                      .getService(Components.interfaces.nsIPrefBranch2);
  1113.   //prefs.addObserver(FLICKR_TOKEN_PREF_ID, timerFunc, false);
  1114.   timer = Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer);
  1115.   timer.initWithCallback(timerFunc, 5 * 1 * 1000, 1);  //re-check token
  1116.  
  1117.   this._profiler.profileEventEnd(evtID, "");
  1118. }
  1119.  
  1120. flickrService.prototype.__defineGetter__('supportsTitle', function () { return this.mSupportsTitle; })
  1121. flickrService.prototype.__defineGetter__('supportsTags', function () { return this.mSupportsTags; })
  1122. flickrService.prototype.__defineGetter__('supportsContacts', function () { return this.mSupportsContacts; })
  1123. flickrService.prototype.__defineGetter__('supportsPrivacy', function () { return this.mSupportsPrivacy; })
  1124.  
  1125. flickrService.prototype.getAuthState =
  1126. function flickrService_getAuthState()
  1127. {
  1128.   return this.state;
  1129. }
  1130.  
  1131. flickrService.prototype.__defineGetter__('authState', function () { return this.state; })
  1132.  
  1133. flickrService.prototype.logout =
  1134. function flickrService_logout()
  1135. {
  1136.   this.api.logout();
  1137.   this.acUtils.removeCookies(this.webDetective.getSessionCookies("flickr"));
  1138. }
  1139.  
  1140. flickrService.prototype.getAuthUser = function () {
  1141.   return this.api.getAuthUser();
  1142. }
  1143.  
  1144. flickrService.prototype.getAuthPerson = function () {
  1145.   var user = this.api.getAuthUser();
  1146.   if (!user) {
  1147.     return null;
  1148.   }
  1149.  
  1150.   var person = {};
  1151.   person.id = user.id;
  1152.   person.fullname = user.fullname;
  1153.   person.username = user.username;
  1154.   person.service = this;
  1155.   return person;
  1156. }
  1157.  
  1158. flickrService.prototype.__defineGetter__('isUploading', function () { return this.running; })
  1159.  
  1160. flickrService.prototype.dictionary2Params =
  1161. function flickrService_dictionary2Params(aDictionary)
  1162. {
  1163.   var params = {};
  1164.   var obj = {};
  1165.   var count = {};
  1166.   var keys = aDictionary.getKeys(count, obj);
  1167.   for (var i = 0; i < keys.length;++i) {
  1168.     var supports = aDictionary.getValue(keys[i]);
  1169.     var supportsString = supports.QueryInterface(Components.interfaces.nsISupportsString);
  1170.     var val = supportsString.toString();
  1171.     params[keys[i]] = val;
  1172.   }
  1173.   return params;
  1174. }
  1175.  
  1176. flickrService.prototype.call =
  1177. function flickrService_call(aListener, aMethod, aDictionary)
  1178. {
  1179.   var params = this.dictionary2Params(aDictionary);
  1180.   this.api.call(aListener, aMethod, params);
  1181. }
  1182.  
  1183. flickrService.prototype.authenticatedCall =
  1184. function flickrService_authenticatedCall(aListener, aMethod, aDictionary)
  1185. {
  1186.   if (!this.getAuthPerson()) {
  1187.     throw "not logged in";
  1188.   }
  1189.   var params = this.dictionary2Params(aDictionary);
  1190.   this.api.authenticatedCall(aListener, aMethod, params);
  1191. }
  1192.  
  1193. flickrService.prototype.upload =
  1194. function flickrService_upload(aListener, aUpload, aFile)
  1195. {
  1196.   var params = {};
  1197.   params.title = aUpload.title;
  1198.   params.description = aUpload.description;
  1199.   params.is_family = aUpload.is_family;
  1200.   params.is_friend = aUpload.is_friend;
  1201.   params.is_public = aUpload.is_public;
  1202.   params.async = "1";
  1203.   params.tags = aUpload.tags;
  1204.   this.api.upload(aListener, aFile, params, aUpload);
  1205. }
  1206.  
  1207. flickrService.prototype.cancelUpload =
  1208. function flickrService_cancelUpload()
  1209. {
  1210.   try { this.api.uploader.req.abort(); }
  1211.   catch(e){};
  1212. }
  1213.  
  1214. flickrService.prototype.addCoopPerson =
  1215. function flickrService_addCoopPerson(aPhotoPerson, aCoopAccount) {
  1216.   var person = aPhotoPerson;
  1217.   // We include the current accountId in the identity urn to prevent friend
  1218.   // collisions if multiple Facebook accounts have the same friend.
  1219.   var identityUrn = _getIdentityUrn(aCoopAccount.accountId,
  1220.                                     person.id);
  1221.   var updating = this.faves_coop.Identity.exists(identityUrn);
  1222.   var identity;
  1223.   if (updating) {
  1224.     identity = this.faves_coop.get(identityUrn);
  1225.     if (this._personUpdateRequired (aCoopAccount,person)) {
  1226.       // update data of the identity coop obj here
  1227.       identity.name = person.username;
  1228.       identity.avatar = person.avatarUrl;
  1229.     }
  1230.   } else {
  1231.     identity = new this.faves_coop.Identity(
  1232.       identityUrn,
  1233.       {
  1234.         name: person.username,
  1235.         serviceId: FLICKR_CONTRACTID,
  1236.         accountId: person.id,
  1237.         avatar: person.avatarUrl,
  1238.         statusMessage: '',
  1239.         lastUpdate: 0,
  1240.         lastUpdateType: "media"
  1241.       }
  1242.     );
  1243.     aCoopAccount.friendsList.children.add(identity);
  1244.   }
  1245.  
  1246.   if (person.media) {
  1247.     this._incrementMedia(person.id, person.media.count, person.media.latest);
  1248.   }
  1249. }
  1250.  
  1251. flickrService.prototype._incrementMedia =
  1252. function flickrService__incrementMedia(aUid, aCount, aLatest) {
  1253.   this._logger.info("._incrementMedia('" + aUid + "')");
  1254.   var currAcctURN = this.acUtils
  1255.                         .getFirstAuthenticatedAccountForService(FLICKR_CONTRACTID);
  1256.   var currAcct = this.faves_coop.get(currAcctURN);
  1257.  
  1258.   // Update the count on the identity...
  1259.   var identityUrn = _getIdentityUrn(currAcct.accountId, aUid);
  1260.   identity = this.faves_coop.get(identityUrn);
  1261.  
  1262.   if (!identity.lastUpdate) {
  1263.     identity.lastUpdate = aLatest;
  1264.     var lastweek = parseInt(Date.now() / 1000) - MEDIA_INITIAL_FETCH;
  1265.     // Friend uploaded pictures in the last week!
  1266.     if (aLatest > lastweek) {
  1267.       identity.unseenMedia += aCount;
  1268.     }
  1269.   } else if (aLatest > identity.lastUpdate) {
  1270.     identity.unseenMedia += aCount;
  1271.     identity.lastUpdate = aLatest;
  1272.   }
  1273. }
  1274.  
  1275. flickrService.prototype._personUpdateRequired =
  1276. function flickrService__personUpdateRequired(aCoopPerson, aPerson) {
  1277.   return (aCoopPerson.name != aPerson.fullname)
  1278.       || (aCoopPerson.avatar != aPerson.pic_square);
  1279. }
  1280.  
  1281. flickrService.prototype._updateUserCommentCount =
  1282. function flickrService__updateUserCommentCount(aCoopAccount)
  1283. {
  1284.   this._logger.info("._updateUserCommentCount('" + aCoopAccount.id() + "')");
  1285.   var timespanMS = 0;
  1286.   if (!aCoopAccount.lastUpdateDate) {
  1287.     // First time refreshing this account, so notify on all photo comments for
  1288.     // the past week.
  1289.     aCoopAccount.lastUpdateDate = new Date();
  1290.     var lastweek = aCoopAccount.lastUpdateDate.getTime()
  1291.                  - (MEDIA_INITIAL_FETCH * 1000);
  1292.     timespanMS = aCoopAccount.lastUpdateDate.getTime() - lastweek;
  1293.     aCoopAccount.flickr_comments = 0;
  1294.     aCoopAccount.flickr_comments_timespan = 0;
  1295.   } else {
  1296.     var today = new Date();
  1297.     timespanMS = today.getTime() - aCoopAccount.lastUpdateDate.getTime();
  1298.   }
  1299.   // This controls the time span (in hours) that photo comments will be shown
  1300.   // for when the user chooses to view comment noties.
  1301.   var timespanHrs = timespanMS / (60 * 60 * 1000);
  1302.   aCoopAccount.flickr_comments_timespan += timespanHrs;
  1303.   
  1304.   var api_key = this.api_key;
  1305.   var params = {
  1306.     api_key: api_key,
  1307.     timeframe: timespanHrs + "h",
  1308.   };
  1309.   var inst = this;
  1310.   var commentListener = {
  1311.     onResult: function commentListener_onResult(aXML) {
  1312.       var items = aXML.getElementsByTagName("item");
  1313.       if (aCoopAccount.flickr_comments < items.length) {
  1314.         inst._lightPeopleIcon();
  1315.       }
  1316.       // Add the flickr_comment count from previous check
  1317.       aCoopAccount.flickr_comments += items.length;
  1318.     },
  1319.     onError: function commentListener_onError(aXML) {
  1320.     }
  1321.   };
  1322.   var dict = params2Dictionary(params);
  1323.   this.authenticatedCall(commentListener, "flickr.activity.userPhotos", dict);
  1324. }
  1325.  
  1326. flickrService.prototype._updateUserAccount =
  1327. function flickrService__updateUserAccount(aCoopAccount)
  1328. {
  1329.   this._logger.info("._updateUserAccount('" + aCoopAccount.id() + "')");
  1330.   var inst = this;
  1331.   var hr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]
  1332.            .createInstance(Ci.nsIXMLHttpRequest);
  1333.   hr.onreadystatechange = function updateAccount_onreadystatechange(aEvent) {
  1334.     if (hr.readyState == 4) {
  1335.       var results = Cc["@mozilla.org/hash-property-bag;1"]
  1336.                     .createInstance(Ci.nsIWritablePropertyBag2);
  1337.       if (inst.webDetective.detectNoDOM("flickr", "accountinfo", "",
  1338.                                         hr.responseText, results))
  1339.       {
  1340.         inst._updateUserStatusFromResults(aCoopAccount, results);
  1341.         inst._updateUserCommentCount(aCoopAccount);
  1342.       }
  1343.     }
  1344.   }
  1345.   hr.open("GET", this.webDetective.getString("flickr", "scrapeAccountInfo",
  1346.                                              "http://www.flickr.com/"));
  1347.   hr.send(null);
  1348. }
  1349.  
  1350. flickrService.prototype._lightPeopleIcon =
  1351. function flickrService__lightPeopleIcon()
  1352. {
  1353.   this._logger.debug("._lightPeopleIcon()");
  1354.   this.obs.notifyObservers(null, "new-people-notification", null);
  1355. }
  1356.  
  1357. flickrService.prototype._updateUserStatusFromResults =
  1358. function flickrService__updateUserAccount(aCoopAccount, aResults)
  1359. {
  1360.   this._logger.info("._updateUserStatusFromResults('" + aCoopAccount.id() + "')");
  1361.   var username = aResults.getPropertyAsAString("username");
  1362.   if (username && username.length) {
  1363.     aCoopAccount.name = username;
  1364.   }
  1365.   var avatarURL = aResults.getPropertyAsAString("avatarURL");
  1366.   if (avatarURL && avatarURL.length) {
  1367.     // If user account has no avatar, set it to null here and people sidebar
  1368.     // code will fill it with the standard Flock no avatar image.
  1369.     var accountid = aResults.getPropertyAsAString("accountid");
  1370.     var noAvatarUrl = gStrings["nomeavataricon"].replace("%owner%", accountid);
  1371.     if (noAvatarUrl == avatarURL) {
  1372.       aCoopAccount.avatar = null;
  1373.     } else {
  1374.       aCoopAccount.avatar = avatarURL;
  1375.     }
  1376.   }
  1377.   var messages = aResults.getPropertyAsAString("messages");
  1378.   if (messages && messages.length) {
  1379.     if (aCoopAccount.accountMessages < messages) {
  1380.       this._lightPeopleIcon();
  1381.     }
  1382.     aCoopAccount.accountMessages = messages;
  1383.   } else {
  1384.     aCoopAccount.accountMessages = 0;
  1385.   }
  1386. }
  1387.  
  1388. // BEGIN flockIPollingService
  1389. flickrService.prototype.refresh =
  1390. function flickrService_refresh(aURN, aListener)
  1391. {
  1392.   this._logger.info("{flockIPollingService}.refresh('"+aURN+"', ...)");
  1393.   var refreshItem = this.faves_coop.get(aURN);
  1394.   var inst = this;
  1395.   if (refreshItem instanceof this.faves_coop.Account) {
  1396.     var peopleHash;
  1397.  
  1398.     if (!this.api.isLoggedIn()) {
  1399.       this._logger.debug("api is not logged in - skipping refresh");
  1400.       aListener.onResult();
  1401.       return;
  1402.     }
  1403.  
  1404.     var recentPhotosListener = {
  1405.       onResult: function recentPhotosListener_onResult(aXML) {
  1406.         var photosList = aXML.getElementsByTagName("photo");
  1407.         for (var i = 0; i < photosList.length; i++) {
  1408.           var photo = photosList[i];
  1409.           var personId = photo.getAttribute("owner");
  1410.           var latest = photo.getAttribute("dateupload");
  1411.  
  1412.           // Add media info to people hash
  1413.           peopleHash[personId].media = {
  1414.             count: 1,
  1415.             latest: latest
  1416.           };
  1417.         }
  1418.  
  1419.         // Now that we have all we need, update the RDF
  1420.         function myWorker(aShouldYield) {
  1421.           // ADD or update existing people
  1422.           for (var uid in peopleHash) {
  1423.             inst.addCoopPerson(peopleHash[uid], refreshItem);
  1424.             if (aShouldYield()) {
  1425.               yield;
  1426.             }
  1427.           }
  1428.  
  1429.           // REMOVE locally people removed on the server
  1430.           var localEnum = refreshItem.friendsList.children.enumerate();
  1431.           while (localEnum.hasMoreElements()) {
  1432.             var identity = localEnum.getNext();
  1433.             if (!peopleHash[identity.accountId]) {
  1434.               inst._logger.info("Friend " + identity.accountId
  1435.                                           + " has been deleted on the server");
  1436.               refreshItem.friendsList.children.remove(identity);
  1437.               identity.destroy();
  1438.             }
  1439.           }
  1440.  
  1441.           if (inst.acUtils.isPeopleSidebarOpen()) {
  1442.             refreshItem.nextRefresh = new Date(Date.now()
  1443.                                                + FLICKR_SHORT_INTERVAL * 1000);
  1444.           }
  1445.           aListener.onResult();
  1446.         } // end myWorker()
  1447.         FlockScheduler.schedule(null, 0.05, 10, myWorker);
  1448.       },
  1449.       onError: function recentPhotosListener_onError(aXML) {
  1450.         inst._logger.error("recentPhotosListener error");
  1451.       }
  1452.     };
  1453.  
  1454.     this._updateUserAccount(refreshItem);
  1455.     this.getContacts({
  1456.       onGetContactsResult: function getContacts_onGetContactsResult(aResult) {
  1457.         peopleHash = aResult.wrappedJS;
  1458.  
  1459.         var api_key = inst.api_key;
  1460.         var params = {
  1461.           api_key: api_key,
  1462.           single_photo: 1,
  1463.           count: 50,
  1464.           extras: "date_upload"
  1465.         };
  1466.  
  1467.         var dict = params2Dictionary(params);
  1468.         inst.authenticatedCall(recentPhotosListener,
  1469.                                "flickr.photos.getContactsPhotos",
  1470.                                dict);
  1471.       },
  1472.       onError: function getContacts_onError(aError) {
  1473.         aListener.onError(aError);
  1474.       }
  1475.     });
  1476.  
  1477.   } else {
  1478.     throw CR.NS_ERROR_ABORT;
  1479.     this._logger.error("can't refresh " + aURN + " (unsupported type)");
  1480.     aListener.onError(null);
  1481.   }
  1482. }
  1483. // END flockIPollingService
  1484.  
  1485.  
  1486. flickrService.prototype.migrateAccount =
  1487. function flickrService_migrateAccount( aId, aUsername ) {
  1488.   this.init();
  1489.  
  1490.   var token = '';
  1491.   /*
  1492.   try {
  1493.     token = flock_getCharPref('flock.photo.flickr.token');
  1494.   } catch (e) { }
  1495.   */
  1496.  
  1497.   this.addAccountById( aId, false, null, aUsername, token);
  1498. }
  1499.  
  1500. // BEGIN flockIWebService interface
  1501. flickrService.prototype.addAccountById =
  1502. function flickrService_addAccountById(aAccountID, aIsTransient, aListener, aUsername, aToken)
  1503. {
  1504.   this._logger.info("{flockIWebService}.addAccountById('"+aAccountID+"', "+aIsTransient+")");
  1505.  
  1506.   if (!aUsername) {
  1507.     // Get the password associated with this account
  1508.     var pw = this.acUtils.getPassword(this.urn+':'+aAccountID);
  1509.     // FIX ME - name shouldn't be email address (pw.user) - ja
  1510.     var name = (pw) ? pw.user : aAccountID;
  1511.     var token = '';
  1512.     var pollable = false;
  1513.     var auth = false;
  1514.   } else {
  1515.     var name = aUsername;
  1516.     var token = aToken;
  1517.     var pollable = true;
  1518.     var auth = true;
  1519.   }
  1520.  
  1521.   // Account
  1522.   var accountURN = "urn:flock:flickr:account:"+aAccountID;
  1523.   var account = this.faves_coop.get(accountURN);
  1524.   if (!account) {
  1525.     var account = new this.faves_coop.Account(accountURN, {
  1526.       name: name,
  1527.       accountId: aAccountID,
  1528.       serviceId: FLICKR_CONTRACTID,
  1529.       service: this.svcCoopObj,
  1530.       favicon: FLICKR_FAVICON,
  1531.       URL: gStrings["userprofile"].replace("%accountid%", aAccountID),
  1532.       isTransient: aIsTransient,
  1533.       isPollable: pollable,
  1534.       refreshInterval: FLICKR_REFRESH_INTERVAL,
  1535.       authToken: token,
  1536.       isAuthenticated: auth,
  1537.       accountMessages: 0
  1538.     });
  1539.     this.faves_coop.accounts_root.children.add(account);
  1540.   }
  1541.   //instansiate the friends list object
  1542.   var friendsListUrn = accountURN + ":friends";
  1543.   if (!account.friendsList) {
  1544.     var friendsList = new this.faves_coop.FriendsList(
  1545.       friendsListUrn,
  1546.       {
  1547.         account: account
  1548.       });
  1549.     account.friendsList = friendsList;
  1550.   }
  1551.   // Instanciate account component
  1552.   var acct = this.getAccount(account.id());
  1553.   if (aListener) {
  1554.     aListener.onSuccess(acct, "addAccount");
  1555.   }
  1556.   return acct;
  1557. }
  1558. // END flockIWebService interface
  1559.  
  1560.  
  1561. // BEGIN flockIAuthenticateNewAccount interface
  1562. flickrService.prototype.authenticateNewAccount =
  1563. function flickrService_authenticateNewAccount(aListener)
  1564. {
  1565.   this._logger.info("{flockIAuthenticateNewAccount}.authenticateNewAccount(aListener)");
  1566.   aListener.onStart(null, "newaccountstarted");
  1567.   var inst = this;
  1568.   var frobListener = {
  1569.     onResult: function (aXML) {
  1570.       inst._logger.info(".authenticateNewAccount(): frobListener: onResult()");
  1571.       var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
  1572.                          .getService(Components.interfaces.nsIWindowMediator);
  1573.       var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
  1574.                          .getService(Components.interfaces.nsIWindowWatcher);
  1575.       var topWin = wm.getMostRecentWindow(null);
  1576.       var frob = aXML.getElementsByTagName("frob")[0].firstChild.nodeValue;
  1577.       var authURL = inst.api.getAuthUrl(frob, "write");
  1578.       var url = "chrome://browser/content/flock/photo/photoLoginWindow.xul?"
  1579.               + "url="+escape(authURL)+"&finalString=logout.gne";
  1580.       var chrome = "chrome,close,titlebar,resizable=yes,toolbar,dialog=no,"
  1581.                  + "scrollbars=yes,modal,centerscreen";
  1582.       topWin.open(url, "_blank", chrome);
  1583.  
  1584.       var acctURN = inst.acUtils.getFirstAuthenticatedAccountForService(FLICKR_CONTRACTID);
  1585.       var account = null;
  1586.       try {
  1587.         account = inst.getAccount(acctURN);
  1588.         if (!account) throw "ACCOUNT WAS NOT CREATED";
  1589.       } catch (ex) {
  1590.         inst._logger.info(".authenticateNewAccount(): frobListener: onResult(): ERROR: account was not created");
  1591.         if (aListener) aListener.onError(ex);
  1592.       }
  1593.       if (aListener) aListener.onSuccess(account, "", null);
  1594.     },
  1595.     onError: function (aError) {
  1596.       inst._logger.info(".authenticateNewAccount(): frobListener: onError()");
  1597.       if (aListener) aListener.onError(aError);
  1598.     }
  1599.   };
  1600.   this.api.call(frobListener, "flickr.auth.getFrob", null);
  1601. }
  1602. // END flockIAuthenticateNewAccount
  1603.  
  1604.  
  1605. // BEGIN flockIManageableWebService interface
  1606. flickrService.prototype.updateAccountStatusFromDocument =
  1607. function flickrService_updateAccountStatusFromDocument(aDocument)
  1608. {
  1609.   this._logger.info("{flockIManageableWebService}.updateAccountStatusFromDocument()");
  1610.   if (this.webDetective.detect("flickr", "loggedout", aDocument, null))
  1611.   {
  1612.     this.acUtils.markAllAccountsAsLoggedOut(FLICKR_CONTRACTID);
  1613.     // Also de-authenticate the API
  1614.     this.api.logout();
  1615.     flock_refreshMediabarIfHasPrivate()
  1616.   } else if (this.webDetective.detect("flickr", "loggedin", aDocument, null)) {
  1617.     var results = Components.classes["@mozilla.org/hash-property-bag;1"]
  1618.                             .createInstance(Components.interfaces.nsIWritablePropertyBag2);
  1619.     if (this.webDetective.detect("flickr", "accountinfo", aDocument, results)) {
  1620.       var accountID = results.getPropertyAsAString("accountid");
  1621.       if (accountID && accountID.length) {
  1622.         var accountURN = this.acUtils.getAccountURNById(this.urn, accountID);
  1623.         var acct = this.faves_coop.get(accountURN);
  1624.         if (!acct.isAuthenticated) {
  1625.           var inst = this;
  1626.           var loginListener = {
  1627.             onSuccess: function (aSubject, aTopic) {
  1628.               inst._logger.info(".updateAccountStatusFromDocument(): loginListener: onSuccess()");
  1629.             },
  1630.             onError: function (aError) {
  1631.               inst._logger.info(".updateAccountStatusFromDocument(): loginListener: onError()");
  1632.               inst._logger.info(aError ? (aError.errorString) : "No details");
  1633.               acct.isAuthenticated = false;
  1634.             }
  1635.           };
  1636.           this.getAccount(accountURN).login(loginListener);
  1637.           // I'm going to somewhat prematurely assume that the authentication
  1638.           // will succeed.  If it fails, the listener will catch it.
  1639.           acct.isAuthenticated = true;
  1640.         }
  1641.       }
  1642.     }
  1643.   }
  1644. }
  1645. // END flockIManageableWebService interface
  1646.  
  1647.  
  1648. // BEGIN flockISocialWebService interface
  1649. flickrService.prototype.markAllMediaSeen =
  1650. function flickrService_markAllMediaSeen(aIdentityUrn) {
  1651.   var identity = this.faves_coop.get(aIdentityUrn);
  1652.   identity.unseenMedia = 0;
  1653. }
  1654.  
  1655. flickrService.prototype.maxStatusLength = 0;
  1656. // END flockISocialWebService interface
  1657.  
  1658.  
  1659. // BEGIN flockIMediaWebService interface
  1660. flickrService.prototype.decorateForMedia =
  1661. function flickrService_decorateForMedia(aDocument)
  1662. {
  1663.   this._logger.info("{flockIMediaWebService}.decorateForMedia(aDocument)");
  1664.   var results = Components.classes["@mozilla.org/hash-property-bag;1"]
  1665.                           .createInstance(Components.interfaces.nsIWritablePropertyBag2);
  1666.   var mediaArr = [];
  1667.   if (this.webDetective.detect("flickr", "person", aDocument, results)) {
  1668.     var media = {
  1669.       name: results.getPropertyAsAString("username"),
  1670.       query: "user:" + results.getPropertyAsAString("userid") + "|username:" + results.getPropertyAsAString("username"),
  1671.       label: results.getPropertyAsAString("username"),
  1672.       favicon: this.icon,
  1673.       service: this.shortName
  1674.     }
  1675.     mediaArr.push(media);
  1676.   }
  1677.   
  1678.   if (this.webDetective.detect("flickr", "pool", aDocument, results)) {
  1679.     var media = {
  1680.       name: results.getPropertyAsAString("groupname"),
  1681.       query: "pool:" + results.getPropertyAsAString("groupid") + "|albumlabel:" + results.getPropertyAsAString("groupname"),
  1682.       label: results.getPropertyAsAString("groupname"),
  1683.       favicon: this.icon,
  1684.       service: this.shortName
  1685.     }
  1686.     mediaArr.push(media);
  1687.   }
  1688.   
  1689.   if (mediaArr.length > 0) {
  1690.     if (!aDocument._flock_decorations) {
  1691.       aDocument._flock_decorations = {};
  1692.     }
  1693.     aDocument._flock_decorations.mediaArr = mediaArr;
  1694.     this.obs.notifyObservers(aDocument, "media", "media:update");
  1695.   }
  1696. }
  1697.  
  1698. flickrService.prototype.handlesMediaStream =
  1699. function flickrService_handlesMediaStream() 
  1700. {
  1701.   return true;
  1702. }
  1703.  
  1704. flickrService.prototype.checkIsStreamUrl =
  1705. function flickrService_checkIsStreamUrl(aUrl)
  1706. {
  1707.   if (this.webDetective.detectNoDOM("flickr", "isStreamUrl", "", aUrl, null)) {
  1708.     this._logger.debug("Checking if url is flickr stream: YES: " + aUrl);
  1709.     return true;
  1710.   }
  1711.   this._logger.debug("Checking if url is flickr stream: NO: " + aUrl);
  1712.   return false;
  1713. }
  1714.  
  1715. flickrService.prototype.getMediaQueryFromURL =
  1716. function flickrService_getMediaQueryFromURL(aUrl, aListener)
  1717. {
  1718.   var myListener = {
  1719.     onResult:function (aXML) {
  1720.       try {
  1721.         var results = Components.classes["@mozilla.org/hash-property-bag;1"]
  1722.                                 .createInstance(Components.interfaces.nsIWritablePropertyBag2);
  1723.         var userID = aXML.getElementsByTagName('user')[0].getAttribute('id');
  1724.         var userName = aXML.getElementsByTagName('username')[0].firstChild.nodeValue;
  1725.  
  1726.         results.setPropertyAsAString("query", "user:" + userID + "|username:" + userName);
  1727.         results.setPropertyAsAString("title", userName);
  1728.         aListener.onSuccess(results, "query");
  1729.       } catch (ex) {
  1730.         aListener.onError(null, "Unable to get user.", null);
  1731.       }
  1732.     },
  1733.     onError: function (aError) {
  1734.         aListener.onError(null, aError.errorString, null);
  1735.     }
  1736.   }
  1737.  
  1738.   this._logger.debug("Finding User ID from Url: " + aUrl);
  1739.   var params = {};
  1740.   params.url = aUrl;
  1741.   var dict = params2Dictionary(params);
  1742.   this.call(myListener, "flickr.urls.lookupUser", dict);
  1743. }
  1744. // END flockIMediaWebService
  1745.  
  1746.  
  1747. // Checks if the TEXTAREA is drag and droppable
  1748. flickrService.prototype._isDnDableTextarea =
  1749. function fs__isDnDableTextarea(aDocument, aXPath, aTextarea) {
  1750.   if (aDocument && aXPath && aTextarea) {
  1751.     var xpath = this.webDetective.getString("flickr", aXPath, "");
  1752.     var results = aDocument.evaluate(xpath, aDocument, null,
  1753.                                      Ci.nsIDOMXPathResult.ANY_TYPE, null);
  1754.     if (results && results.iterateNext() == aTextarea) {
  1755.       return true;
  1756.     }
  1757.   }
  1758.   return false;
  1759. }
  1760.  
  1761.  
  1762. // BEGIN flockIRichContentDropHandler
  1763. flickrService.prototype.handleDrop =
  1764. function flickrService_handleDrop(aFlavours, aTextarea)
  1765. {
  1766.   this._logger.info(".handleDrop()");
  1767.  
  1768.   var dropCallback = function flickr_dropCallback(aFlav) {
  1769.     var data = {}, len = {};
  1770.     aFlavours.getTransferData(aFlav, data, len);
  1771.     var caretPos = aTextarea.selectionEnd;
  1772.     var currentValue = aTextarea.value;
  1773.     // Add a trailing space so that we don't mangle the url
  1774.     var nextChar = currentValue.charAt(caretPos);
  1775.     var trailingSpace = ((nextChar == "") ||
  1776.                          (nextChar == " ") || 
  1777.                          (nextChar == "\n"))
  1778.                       ? ""
  1779.                       : " ";
  1780.     // Only add a breadcrumb if the insertion point is at the end of
  1781.     // the text so that we don't duplicate breadcrumbs
  1782.     var breadcrumb = (aTextarea.value.length == aTextarea.selectionEnd)
  1783.                    ? Cc[FLOCK_RDDS_CONTRACTID]
  1784.                        .getService(Ci.flockIRichDNDService)
  1785.                        .getBreadcrumb("plain")
  1786.                    : "";
  1787.  
  1788.     aTextarea.value = currentValue.substring(0, caretPos)
  1789.                     + data.value.QueryInterface(Ci.nsISupportsString)
  1790.                           .data.replace(/: /, ":\n")
  1791.                     + trailingSpace
  1792.                     + currentValue.substring(caretPos)
  1793.                     + breadcrumb;
  1794.   };
  1795.  
  1796.   return this._handleTextareaDrop(CATEGORY_ENTRY_NAME, this.svcCoopObj.domains,
  1797.                                   aTextarea, dropCallback);
  1798. }
  1799. // END flockIRichContentDropHandler
  1800.  
  1801.  
  1802. // ========== END flickrService class ==========
  1803.  
  1804.  
  1805.  
  1806. // ================================================
  1807. // ========== BEGIN XPCOM Module support ==========
  1808. // ================================================
  1809.  
  1810. function createModule(aParams) {
  1811.   return {
  1812.     registerSelf: function (aCompMgr, aFileSpec, aLocation, aType) {
  1813.       aCompMgr.QueryInterface(Ci.nsIComponentRegistrar);
  1814.       aCompMgr.registerFactoryLocation( aParams.CID, aParams.componentName,
  1815.                                         aParams.contractID, aFileSpec,
  1816.                                         aLocation, aType );
  1817.       var catMgr = Cc["@mozilla.org/categorymanager;1"]
  1818.         .getService(Ci.nsICategoryManager);
  1819.       if (!aParams.categories) { aParams.categories = []; }
  1820.       for (var i = 0; i < aParams.categories.length; i++) {
  1821.         var cat = aParams.categories[i];
  1822.         catMgr.addCategoryEntry( cat.category, cat.entry,
  1823.                                  cat.value, true, true );
  1824.       }
  1825.     },
  1826.     getClassObject: function (aCompMgr, aCID, aIID) {
  1827.       if (!aCID.equals(aParams.CID)) { throw Cr.NS_ERROR_NO_INTERFACE; }
  1828.       if (!aIID.equals(Ci.nsIFactory)) { throw Cr.NS_ERROR_NOT_IMPLEMENTED; }
  1829.       return { // Factory
  1830.         createInstance: function (aOuter, aIID) {
  1831.           if (aOuter != null) { throw Cr.NS_ERROR_NO_AGGREGATION; }
  1832.           var comp = new aParams.componentClass();
  1833.           if (aParams.implementationFunc) { aParams.implementationFunc(comp); }
  1834.           return comp.QueryInterface(aIID);
  1835.         }
  1836.       };
  1837.     },
  1838.     canUnload: function (aCompMgr) { return true; }
  1839.   };
  1840. }
  1841.  
  1842. // NS Module entrypoint
  1843. function NSGetModule(aCompMgr, aFileSpec) {
  1844.   return createModule({
  1845.     componentClass: flickrService,
  1846.     CID: FLICKR_CID,
  1847.     contractID: FLICKR_CONTRACTID,
  1848.     componentName: CATEGORY_COMPONENT_NAME,
  1849.     implementationFunc: function (aComp) { getCompTK().addAllInterfaces(aComp); },
  1850.     categories: [
  1851.       { category: "wsm-startup", entry: CATEGORY_COMPONENT_NAME, value: FLICKR_CONTRACTID },
  1852.       { category: "flockWebService", entry: CATEGORY_ENTRY_NAME, value: FLICKR_CONTRACTID },
  1853.       { category: "flockMediaProvider", entry: CATEGORY_ENTRY_NAME, value: FLICKR_CONTRACTID },
  1854.       { category: "flockRichContentHandler", entry: CATEGORY_ENTRY_NAME, value: FLICKR_CONTRACTID }
  1855.     ]
  1856.   });
  1857. }
  1858.  
  1859. // ========== END XPCOM Module support ==========
  1860.  
  1861.  
  1862.  
  1863. // =============================================
  1864. // ========== BEGIN MultiGetter class ==========
  1865. // =============================================
  1866.  
  1867. function MultiGetter() {
  1868. }
  1869.  
  1870. MultiGetter.prototype = {
  1871.   mTimer: Components.classes["@mozilla.org/timer;1"].createInstance(Components.interfaces.nsITimer),
  1872.   init: function(aSvc, aListener, aEnumerator) {
  1873.     this.mHasNew = false;
  1874.     this.mNeedSave = false;
  1875.     this.mSvc = aSvc;
  1876.     this.mListener = aListener;
  1877.     this.mArray = [];
  1878.     this.mMap = {};
  1879.     while (aEnumerator.hasMoreElements()) {
  1880.       var p = aEnumerator.getNext();
  1881.       p.QueryInterface(Components.interfaces.flockIPhotoPerson);
  1882.  
  1883.       this.mMap[p.id] = p;
  1884.       this.mArray.push(p.id);
  1885.       //this._logger.info(p + " " + p.id + " " + this.mArray.length + " initting \n");
  1886.     }
  1887.     if (this.mSvc.getAuthPerson()) {
  1888.       this.doBiggee();
  1889.     }
  1890.     else {
  1891.       this.next();
  1892.     }
  1893.   },
  1894.   updatePerson: function(aPerson, aPhoto) {
  1895.     //this._logger.info(aPerson.username + "updating person\n");
  1896.     var seq = aPerson.seq;
  1897.     var newSeq = parseInt(aPhoto.id);
  1898.     if (newSeq > seq) {
  1899.       var oldHasNew = aPerson.hasNew;
  1900.       aPerson.seq = aPhoto.id;
  1901.       this.mNeedSave = true;
  1902.       if (seq != 0) {
  1903.         this.mHasNew = true;
  1904.         aPerson.hasNew = true;
  1905.         if (oldHasNew == false) {
  1906.           aPerson.lastNewSeq = seq + 1;
  1907.         }
  1908.       }
  1909.     }
  1910.     this.mMap[aPerson.id] = null;// wipe this entry out
  1911.   },
  1912.   doBiggee: function() {
  1913.     var inst = this;
  1914.     var listener = {
  1915.       onSearchResult: function(aEnumerator) {
  1916.         //this._logger.info("on search result\n");
  1917.         try {
  1918.           while (aEnumerator.hasMoreElements()) {
  1919.             var photo = aEnumerator.getNext();
  1920.             var person = inst.mMap[photo.userid];  // username is actuall an id
  1921.             //this._logger.info("result\n")
  1922.             if (!person) continue;
  1923.             inst.updatePerson(person, photo);
  1924.           }
  1925.         } catch(e) {
  1926.           //this._logger.info("this" + e + " " + e.lineNumber + "\n");
  1927.         }
  1928.         inst.next();
  1929.       },
  1930.       onError: function(aError) {
  1931.         //this._logger.info("on error result\n");
  1932.         //hmm. mebbe should bail
  1933.         inst.finish();
  1934.       }
  1935.     }
  1936.     this.mSvc.getContactsPhotos(listener);
  1937.   },
  1938.   finish: function() {
  1939.     //this._logger.info("FINITI\n");
  1940.     if (this.mHasNew) {
  1941.       this.mListener.onGetMostRecentPhotoForList(Components.interfaces.flockIPhotoAPIListener.LIST_HAS_NEW);
  1942.     }
  1943.     else if (this.mNeedSave) {
  1944.       this.mListener.onGetMostRecentPhotoForList(Components.interfaces.flockIPhotoAPIListener.LIST_NEED_SAVE);
  1945.     }
  1946.     else {
  1947.       this.mListener.onGetMostRecentPhotoForList(Components.interfaces.flockIPhotoAPIListener.LIST_NO_CHANGE);
  1948.     }
  1949.     return;
  1950.   },
  1951.   notify: function() {
  1952.     this.doNext();
  1953.   },
  1954.   next: function() {
  1955.     this.mTimer.initWithCallback(this, 1000, 0);
  1956.   },
  1957.   doNext: function() {
  1958.     //this._logger.info("NEXT PLEASE\n");
  1959.     var inst = this;
  1960.     var person = null;
  1961.     for (;;) {
  1962.       if (!this.mArray.length) break;
  1963.       var id = this.mArray.pop();
  1964.       //this._logger.info(id + " " + "< NEXT PLEASE\n");
  1965.       person = this.mMap[id];
  1966.       if (person) {
  1967.         break;
  1968.       }
  1969.     }
  1970.     if (!person) {
  1971.       this.finish();
  1972.       return;
  1973.     }
  1974.  
  1975.     var listener = {
  1976.       onSearchResult: function(aEnumerator) {
  1977.         //this._logger.info("b search result\n");
  1978.         while (aEnumerator.hasMoreElements()) {
  1979.           var photo = aEnumerator.getNext();
  1980.           var person = inst.mMap[photo.userid];  // username is actuall an id
  1981.           inst.updatePerson(person, photo);
  1982.           break;
  1983.         }
  1984.         inst.next();
  1985.       },
  1986.       onError: function(aError) {
  1987.         //this._logger.info("b search eror\n");
  1988.         inst.finish();
  1989.       }
  1990.     }
  1991.     this.mSvc.search(listener, person.id, "", "", 1, 1);
  1992.   }
  1993. }
  1994.  
  1995. // ========== END MultiGetter class ==========
  1996.  
  1997.  
  1998.  
  1999. // ===========================================
  2000. // ========== BEGIN FlickrAPI class ==========
  2001. // ===========================================
  2002.  
  2003. function FlickrAPI() {
  2004.   this._logger = Components.classes['@flock.com/logger;1'].createInstance(Components.interfaces.flockILogger);
  2005.   this._logger.init('flickrAPI');
  2006.   this._logger.info('Created Flickr API Object');
  2007.   this.acUtils = Components.classes["@flock.com/account-utils;1"]
  2008.                            .getService(Components.interfaces.flockIAccountUtils);
  2009.   this.webDetective = this.acUtils.useWebDetective("flickr.xml");
  2010.   this.faves_coop = Components.classes["@flock.com/singleton;1"]
  2011.                               .getService(Components.interfaces.flockISingleton)
  2012.                               .getSingleton("chrome://flock/content/common/load-faves-coop.js")
  2013.                               .wrappedJSObject;
  2014.  
  2015.   var inst = this;
  2016.   this.need2CreateAlbum = false;
  2017.   this.api_key = gStrings["apikey"];
  2018.   this.api_secret = "17b26c20558cf979";
  2019.   this.endpoint = gStrings["endpoint"];
  2020.   this.upload_endpoint = gStrings["uploadendpoint"];
  2021.   this.auth_endpoint = gStrings["authendpoint"];
  2022.   this.fakeAlbums = {};
  2023.   this.realishAlbums = {};
  2024.  
  2025.   this.req = null;
  2026.   this.frob = null;
  2027.   this.lastToken = new Date();
  2028.   this.authUser = null;
  2029.   this.filesToDelete = [];
  2030.   this.setEndpoint = function(aEndpoint) {
  2031.     this.endpoint = aEndpoint;
  2032.   };
  2033.  
  2034.   this.reset = function() {
  2035.     this.hasCreateAlbum = null;
  2036.   };
  2037.  
  2038.   this.getAuthUser = function() {
  2039.     return this.authUser;
  2040.   };
  2041.   this.getStoredToken = function(aListener) {
  2042.   };
  2043.   this.checkToken = function(aListener, aToken) {
  2044.     var tokenListener = {
  2045.       onResult: function (aXML) {
  2046.         var flickrUser = new FlickrUser();
  2047.         flickrUser.token = aXML.getElementsByTagName("token")[0].firstChild.nodeValue;
  2048.         var user = aXML.getElementsByTagName("user")[0];
  2049.         flickrUser.nsid = user.getAttribute("nsid");
  2050.         flickrUser.id = user.getAttribute("nsid");
  2051.         flickrUser.username = user.getAttribute("username");
  2052.         flickrUser.fullname = user.getAttribute("fullname");
  2053.         inst.authUser = flickrUser;
  2054.  
  2055.         inst._logger.info("token checks out");
  2056.         inst.lastToken = new Date();
  2057.         aListener.onSuccess(null, "");
  2058.       },
  2059.       onError: function (aError) {
  2060.         inst._logger.info("Token does not pass muster");
  2061.         inst.frob = null;
  2062.         aListener.onError(null);
  2063.       }
  2064.     }
  2065.     var token = aToken;
  2066.     var params = {
  2067.       auth_token: token
  2068.     };
  2069.     this.call(tokenListener, "flickr.auth.checkToken", params);
  2070.   };
  2071.   this.getToken = function(aAccountURN, aListener) {
  2072.     inst._logger.info("entering getToken");
  2073.     var acctCoopObj = this.faves_coop.get(aAccountURN);
  2074.     var flickrUser = new FlickrUser();
  2075.  
  2076.     // we have an existing token, let's see if it's valid
  2077.     if (acctCoopObj.authToken && acctCoopObj.authToken.length) {
  2078.       var checkTokenListener = {
  2079.         onSuccess : function(aSubject, aTopic) {
  2080.           // the token is aiighttt lets reuse it
  2081.           inst._reuseToken(aAccountURN, aListener);
  2082.         },
  2083.  
  2084.         onError: function(aError) {
  2085.           // something
  2086.           inst._getNewToken(aAccountURN, aListener);
  2087.         }
  2088.       };
  2089.       this.checkToken(checkTokenListener, acctCoopObj.authToken);
  2090.     } else {
  2091.       this._getNewToken(aAccountURN, aListener);
  2092.     }
  2093.   };
  2094.   this._reuseToken = function(aAccountURN, aListener)  {
  2095.     inst._logger.info("entering _reuseToken");
  2096.     var acctCoopObj = inst.faves_coop.get(aAccountURN);
  2097.     var flickrUser = new FlickrUser();
  2098.  
  2099.     flickrUser.token = acctCoopObj.authToken;
  2100.     flickrUser.nsid = acctCoopObj.flickr_nsid;
  2101.     flickrUser.id = acctCoopObj.flickr_id;
  2102.     flickrUser.username = acctCoopObj.flickr_username;
  2103.     flickrUser.fullname = acctCoopObj.flickr_fullname;
  2104.     this.authUser = flickrUser;
  2105.     inst.acUtils.ensureOnlyAuthenticatedAccount(aAccountURN);
  2106.  
  2107.   };
  2108.   this._getNewToken = function(aAccountURN, aListener, aFrob) {
  2109.     inst._logger.info("entering _getNewToken");
  2110.     var acctCoopObj = inst.faves_coop.get(aAccountURN);
  2111.     var flickrUser = new FlickrUser();
  2112.     var tokenListener = {
  2113.         onResult: function (aXML) {
  2114.           flickrUser.token = aXML.getElementsByTagName("token")[0].firstChild.nodeValue;
  2115.           var user = aXML.getElementsByTagName("user")[0];
  2116.           flickrUser.nsid = user.getAttribute("nsid");
  2117.           flickrUser.id = user.getAttribute("nsid");
  2118.           flickrUser.username = user.getAttribute("username");
  2119.           flickrUser.fullname = user.getAttribute("fullname");
  2120.           inst.authUser = flickrUser;
  2121.  
  2122.           acctCoopObj.authToken = flickrUser.token;
  2123.           acctCoopObj.flickr_nsid = flickrUser.nsid;
  2124.           acctCoopObj.flickr_id = flickrUser.id;
  2125.           acctCoopObj.flickr_username = flickrUser.username;
  2126.           acctCoopObj.flickr_fullname = flickrUser.fullname;
  2127.           inst.acUtils.ensureOnlyAuthenticatedAccount(aAccountURN);
  2128.  
  2129.           inst._logger.info("got token");
  2130.           this.lastToken = new Date();
  2131.           aListener.onSuccess();
  2132.         },
  2133.         onError: function (aError) {
  2134.           inst._logger.info("error getting token");
  2135.           this.frob = null;
  2136.           if (!aError.errorCode) aError.errorCode = 1002;
  2137.           aListener.onError(aError);
  2138.         }
  2139.       }
  2140.  
  2141.       var frob = aFrob;
  2142.       if (!frob) {
  2143.         frob = this.frob;
  2144.       }
  2145.       var params = {
  2146.         frob: frob
  2147.       };
  2148.       this.call(tokenListener, "flickr.auth.getToken", params);
  2149.   },
  2150.   this.isLoggedIn = function() {
  2151.     if (this.authUser) return true;
  2152.     return false;
  2153.   };
  2154.   this.logout = function() {
  2155.     this.authUser = null;
  2156.     this.frob = null;
  2157.     this.token = null;
  2158.     flock_refreshMediabarIfHasPrivate()
  2159.   };
  2160.   this.login = function(aAccountURN, aListener) {
  2161.     inst._logger.info("api.login('"+aAccountURN+"')");
  2162.     this.authUser = null;
  2163.     this.frob = null;
  2164.     var api = this;
  2165.  
  2166.     // for http://bugzilla.flock.com/show_bug.cgi?id=6255 --
  2167.     // ensure that the frob and auth token synch up
  2168.     if (0 /*acctCoopObj.authToken && acctCoopObj.authToken.length*/) {
  2169.       inst._logger.info("api.login('"+aAccountURN+"'): trying to reuse token");
  2170.       var reuseTokenListener = {
  2171.         onResult: function (aXML) {
  2172.           inst._logger.info("api.login('"+aAccountURN+"') reuseTokenListener: onResult()");
  2173.           aListener.onSuccess();
  2174.         },
  2175.         onError: function (aError) {
  2176.           inst._logger.info("api.login('"+aAccountURN+"') reuseTokenListener: onError()");
  2177.           aListener.onError(aError);
  2178.         }
  2179.       };
  2180.  
  2181.      this.getToken(aAccountURN, reuseTokenListener);
  2182.     } else {
  2183.      // get new frob
  2184.      inst._logger.info("api.login('"+aAccountURN+"'): need new token");
  2185.       var frobListener = {
  2186.         onResult: function (aXML) {
  2187.           try {
  2188.             var frobNode = aXML.getElementsByTagName("frob")[0];
  2189.             var frob = frobNode.firstChild.nodeValue;
  2190.             var authUrl = api.getAuthUrl(frob, "write");
  2191.             inst.frob = frob;
  2192.             api.frob = frob;
  2193.  
  2194.             var hr = Components.classes['@mozilla.org/xmlextras/xmlhttprequest;1']
  2195.                                .createInstance(Components.interfaces.nsIXMLHttpRequest);
  2196.  
  2197.             var onReadyStateFunc = function (eEvt) {
  2198.               if (hr.readyState == 4) {
  2199.                 if (api.webDetective.detectNoDOM("flickr", "apiAuth2", "", hr.responseText, null)) {
  2200.                   inst._logger.info("Successfully authorized2!");
  2201.                   api._getNewToken(aAccountURN, aListener, frob);
  2202.                 } else {
  2203.                   var results = Components.classes["@mozilla.org/hash-property-bag;1"]
  2204.                               .createInstance(Components.interfaces.nsIWritablePropertyBag2);
  2205.                   //dump("CDC: apiAuth1: "+hr.responseText+"\n");
  2206.                   if (api.webDetective.detectNoDOM("flickr", "apiAuth1", "", hr.responseText, results)) {
  2207.  
  2208.                     var hr2 = Components.classes["@mozilla.org/xmlextras/xmlhttprequest;1"]
  2209.                                         .createInstance(Components.interfaces.nsIXMLHttpRequest);
  2210.                     var postBody = "magic_cookie=" + results.getPropertyAsAString("magic_cookie")
  2211.                                 + "&api_key=" + api.api_key
  2212.                                 + "&api_sig=" + results.getPropertyAsAString("api_sig")
  2213.                                 + "&perms=write"
  2214.                                 + "&frob=" + frob
  2215.                                 + "&done_auth=1";
  2216.                     hr2.onreadystatechange = function (eEvt2) {
  2217.                       if (hr2.readyState == 4) {
  2218.                         if (api.webDetective.detectNoDOM("flickr", "apiAuth2", "", hr2.responseText, null)) {
  2219.                           inst._logger.info("Successfully authorized!");
  2220.                           api._getNewToken(aAccountURN, aListener, frob);
  2221.                         } else {
  2222.                           inst._logger.info("NOT successfully authorized!");
  2223.                           inst._logger.info(hr2.responseText);
  2224.                           aListener.onError(null);
  2225.                         }
  2226.                       }
  2227.                     }
  2228.                     hr2.backgroundRequest = true;
  2229.                     hr2.overrideMimeType("text/txt");
  2230.                     hr2.open("POST", gStrings["authendpoint"]);
  2231.                     hr2.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
  2232.                     hr2.send(postBody);
  2233.  
  2234.                   } else if (api.webDetective.detectNoDOM("flickr", "apiAuth3", "", hr.responseText, null)) {
  2235.                     inst._logger.info("Successfully authorized with apiAuth3!");
  2236.                     api._getNewToken(aAccountURN, aListener, frob);
  2237.                   } else {
  2238.                     inst._logger.debug("Error - did not detect apiAuth1 or apiAuth3");
  2239.                     aListener.onError(null);
  2240.                   }
  2241.                 }
  2242.               }
  2243.             };
  2244.  
  2245.             hr.onreadystatechange = onReadyStateFunc;
  2246.             hr.backgroundRequest = true;
  2247.             hr.overrideMimeType("text/txt");
  2248.             hr.open("GET", authUrl,true);
  2249.             hr.send(null);
  2250.             //var topWindow = windowManagerInterface.getMostRecentWindow(null);
  2251.             //var url = "chrome://browser/content/flock/photo/photoLoginWindow.xul?"+"url="+escape(authUrl)+"&finalString=logout.gne";
  2252.             //topWindow.open(url,"_blank", "chrome,close,titlebar,resizable=yes,toolbar,dialog=no,scrollbars=yes,modal,centerscreen");
  2253.           }
  2254.           catch(e) {
  2255.             inst._logger.info("caught this one in login: " + e);
  2256.           }
  2257.         },
  2258.         onError: function (aError) {
  2259.           inst._logger.debug("There was an error getting the frob.");
  2260.           aListener.onError(aError);
  2261.         }
  2262.       };
  2263.       this.call(frobListener, "flickr.auth.getFrob", null);
  2264.     }
  2265.   };
  2266.   this.add2Album = function(aUploadListener, aUpload, aID) {
  2267.     var inst = this;
  2268.     var listener = {
  2269.       onResult: function(aXML) {
  2270.         inst.finalizePhoto(aUploadListener, aUpload, aID);
  2271.       },
  2272.       onError: function(aError) {
  2273.         inst.finalizePhoto(aUploadListener, aUpload, aID);
  2274.       }
  2275.     }
  2276.     var params = {};
  2277.     params.photoset_id = aUpload.album;
  2278.     params.photo_id = aID;
  2279.     this.authenticatedCall(listener, "flickr.photosets.addPhoto", params);
  2280.   };
  2281.   this.reallyCreateAlbum =
  2282.   function flickrAPI_reallyCreateAlbum(aListener, aTitle, aID) {
  2283.     var myListener = {
  2284.       onResult: function fAPIrCA_onResult(aXML) {
  2285.         var newAlbum = Cc[FLOCK_PHOTO_ALBUM_CONTRACTID]
  2286.                        .createInstance(Ci.flockIPhotoAlbum);
  2287.         var photoset = aXML.getElementsByTagName("photoset")[0];
  2288.         newAlbum.title = aTitle;
  2289.         newAlbum.id = photoset.getAttribute("id");;
  2290.         aListener.onCreateAlbumResult(newAlbum);
  2291.       },
  2292.       onError: function fAPIrCA_onError(aXML) {
  2293.         aListener.onError(aXML);
  2294.       }
  2295.     }
  2296.     var params = {
  2297.       title: aTitle,
  2298.       primary_photo_id: aID
  2299.     };
  2300.     this.authenticatedCall(myListener, "flickr.photosets.create", params);
  2301.   };
  2302.   this.finalizePhoto = function(aUploadListener, aUpload, aID) {
  2303.     try {
  2304.       var inst = this;
  2305.       var getPhotoListener = {
  2306.         onGetPhoto: function(aPhoto) {
  2307.           aUploadListener.onUploadFinalized(aUpload, aPhoto);
  2308.         },
  2309.         onError: function(aError) {
  2310.           aUploadListener.onError(null);
  2311.         }
  2312.       }
  2313.       inst.svc.getPhoto(getPhotoListener, aID);
  2314.     } catch(e) {
  2315.       inst._logger.error(e);
  2316.     }
  2317.   };
  2318.   this.mAddingAlbums = false;
  2319.   this.mPhotos2Album = [];
  2320.   this.processPendingAlbumAdditions = function() {
  2321.     if (this.mAddingAlbums) return;
  2322.     if (this.mPhotos2Album.length == 0) return;
  2323.     this.mAddingAlbums = true;
  2324.  
  2325.     var obj = this.mPhotos2Album[0];
  2326.     var photoid = obj.photoid;
  2327.     var albumid = obj.albumid;
  2328.     var inst = this;
  2329.  
  2330.     if (this.fakeAlbums[albumid] && !this.realishAlbums[albumid]) {
  2331.       var listener = {
  2332.         onCreateAlbumResult: function(aAlbum) {
  2333.           inst.realishAlbums[albumid] = aAlbum.id;
  2334.           inst.mAddingAlbums = false;
  2335.         },
  2336.         onError: function(aError) {
  2337.           inst.mAddingAlbums = false;
  2338.         }
  2339.       }
  2340. //      var params = {};
  2341. //      params.photoset_id = photoid;
  2342. //      params.photo_id = albumid;
  2343.       var fakeAlbum = this.fakeAlbums[albumid];
  2344.       this.reallyCreateAlbum(listener,  fakeAlbum.title, photoid);
  2345.     }
  2346.     else {
  2347.       if (inst.realishAlbums[albumid]) {
  2348.         albumid = inst.realishAlbums[albumid];
  2349.       }
  2350.       var listener = {
  2351.         onResult: function(aXML) {
  2352.           inst.finalizePhoto(obj.listener, obj.upload, photoid);
  2353.           inst.mPhotos2Album.shift();
  2354.           inst.mAddingAlbums = false;
  2355.           inst.processPendingAlbumAdditions();
  2356.           //re-enter to optimize
  2357.         },
  2358.         onError: function(aError) {
  2359.           inst.finalizePhoto(obj.listener, obj.upload, photoid);
  2360.           inst.mPhotos2Album.shift();
  2361.           inst.mAddingAlbums = false;
  2362.           //re-enter to optimize?? this is an error condition, por
  2363.           //supuesto
  2364.         }
  2365.       }
  2366.       var params = {};
  2367.       params.photoset_id = albumid;
  2368.       params.photo_id = photoid;
  2369.       this.authenticatedCall(listener, "flickr.photosets.addPhoto", params);
  2370.     }
  2371.   };
  2372.   this.mCheckTicketsInProcess = false;
  2373.   this.processPendingUploadTickets = function() {
  2374.     if (this.mCheckTicketsInProcess) return;
  2375.  
  2376.     var ticketList = "";
  2377.  
  2378.     for (var p in this.mPendingTickets) {
  2379.       var obj = this.mPendingTickets[p];
  2380.       if (!obj) continue;//really should be removeing these - make it an array?
  2381.       ticketList += obj.ticketid + ",";
  2382.     }
  2383.     if (ticketList.length == 0) return;
  2384.  
  2385.     this.mCheckTicketsInProcess = true;
  2386.  
  2387.     var params = {
  2388.       tickets: ticketList
  2389.     };
  2390.  
  2391.     var inst = this;
  2392.  
  2393.     var ticketListener = {
  2394.       onResult: function (aXML) {
  2395.         inst.mCheckTicketsInProcess = false;
  2396.         var ticketList = aXML.getElementsByTagName("ticket");
  2397.         for (var i = 0; i < ticketList.length; i++) {
  2398.           var ticket = ticketList[i];
  2399.           var id = ticket.getAttribute("id");
  2400.           var photoid = ticket.getAttribute("photoid");
  2401.           var complete = ticket.getAttribute("complete");
  2402.           var invalid = ticket.getAttribute("invalid");
  2403.           var obj = inst.mPendingTickets[id];
  2404.  
  2405.           if (complete =="0") {
  2406.             continue;
  2407.           }
  2408.           else if (invalid) {
  2409.             obj.listener.onError(null);
  2410.           }
  2411.           else if (complete =="1") {
  2412.             if (obj.upload.album && obj.upload.album.length>0) {
  2413.               obj.photoid = photoid;
  2414.               obj.albumid = obj.upload.album;
  2415.               obj.listener = obj.listener;
  2416.               inst.mPhotos2Album.push(obj);
  2417.             }
  2418.             else {
  2419.               inst.finalizePhoto(obj.listener, obj.upload, photoid);
  2420.             }
  2421.           }
  2422.           else if (complete =="2") {
  2423.             obj.listener.onError(null);
  2424.           }
  2425.           inst.mPendingTickets[id] = null;//that doesn't really remove it tho
  2426.         }
  2427.       },
  2428.       onError: function (aXML) {
  2429.         inst.mCheckTicketsInProcess = false;
  2430.       }
  2431.     }
  2432.  
  2433.     this.call(ticketListener, "flickr.photos.upload.checkTickets", params);
  2434.   };
  2435.   this.mPendingTickets = {};
  2436.   this.upload = function(aListener, aPhoto, aParams, aUpload) {
  2437.     var inst = this;
  2438.     this.uploader = new PhotoUploader();
  2439.     var myListener = {
  2440.       onResult: function(aXML) {
  2441.         var rsp = aXML.getElementsByTagName("rsp")[0];
  2442.         var stat = rsp.getAttribute("stat");
  2443.         if (stat !="ok") {
  2444.           var err = aXML.getElementsByTagName("err")[0];
  2445.           var error= inst.getError('SERVICE_ERROR', aXML, null);
  2446.           aListener.onError(error);
  2447.         }
  2448.         else {
  2449.           aListener.onUploadComplete(aUpload);
  2450.           var ticketid = aXML.getElementsByTagName("ticketid")[0].firstChild.nodeValue;
  2451.           inst._logger.info(ticketid + "pre ticketid");
  2452.           inst.mPendingTickets[ticketid] = {
  2453.             ticketid: ticketid,
  2454.             upload: aUpload,
  2455.             listener: aListener
  2456.           }
  2457.           inst._logger.info(ticketid + "post ticketid");
  2458.           /*
  2459.           if (aUpload.album && aUpload.album.length>0) {
  2460.             var ticketid = aXML.getElementsByTagName("ticketid")[0].firstChild.nodeValue;
  2461.             inst.mPendingTickets[ticketid] = {
  2462.               ticketid: ticketid,
  2463.               upload: aUpload,
  2464.               listener: aListener,
  2465.             }
  2466.           }
  2467.           else {
  2468.             aListener.onUploadFinalized(aUpload, null);
  2469.           }
  2470.           */
  2471.         }
  2472.       },
  2473.       onError: function(aErrorCode) {
  2474.         if (aErrorCode) {
  2475.           aListener.onError(inst.getError('HTTP_ERROR', null, aErrorCode));
  2476.         } else {
  2477.           aListener.onError(inst.getError('SERVICE_ERROR', null));
  2478.         }
  2479.       },
  2480.       onProgress: function(aCurrentProgress) {
  2481.         aListener.onProgress(aCurrentProgress);
  2482.       }
  2483.     }
  2484.     this.convertBools(aParams);
  2485.     this.convertTags(aParams);
  2486.  
  2487.     aParams.auth_token = this.authUser.token;
  2488.     aParams.api_key = this.api_key;
  2489.     aParams = this.appendSignature(aParams);
  2490.  
  2491.     this.uploader.setEndpoint(this.upload_endpoint);
  2492.     this.uploader.upload(myListener, aPhoto, aParams);
  2493.     return;
  2494.   };
  2495.   this.convertBools = function(aParams) {
  2496.     for (var p in aParams) {
  2497.       if (!p.match(/^is/)) continue;
  2498.       // I hope that this doesn't break anything
  2499.       if (aParams[p]=="true") aParams[p] = "1";
  2500.       if (aParams[p]=="false") aParams[p] = "0";
  2501.     }
  2502.   };
  2503.   this.convertTags = function(aParams) {
  2504.     for (var p in aParams) {
  2505.       if (p != "tags") continue;
  2506.       var tags = aParams[p].split(",");
  2507.       for (var i = 0; i < tags.length;++i) {
  2508.         tags[i] = '"' + tags[i] + '"';
  2509.         tags[i] = tags[i].replace(/\"+/g,'"');
  2510.       }
  2511.       aParams[p] = tags.join(",");
  2512.     }
  2513.   };
  2514.   this.authenticatedCall = function(aListener, aMethod, aParams) {
  2515.     if (!aParams) aParams = {};
  2516.     aParams.auth_token = this.authUser.token;
  2517.     this.call(aListener, aMethod, aParams);
  2518.     var paramString = this.getParamString(aParams, true);
  2519.   };
  2520.   this.call = function(aListener, aMethod, aParams) {
  2521.     this.convertBools(aParams);
  2522.     this.convertTags(aParams);
  2523.     if (aParams == null) aParams = [];
  2524.     if (aMethod) aParams.method = aMethod;
  2525.     aParams.api_key = this.api_key;
  2526.     var paramString = this.getParamString(aParams, (aMethod == null));
  2527.     var url = this.endpoint + "?" + paramString;
  2528.     this._doCall(aListener, url, null);
  2529.   };
  2530.   this._doCall = function(aListener, aUrl, aContent) {
  2531.     inst._logger.info("Sending " + aUrl);
  2532.     this.req = Components.classes['@mozilla.org/xmlextras/xmlhttprequest;1']
  2533.                          .createInstance(Components.interfaces.nsIXMLHttpRequest);
  2534.     this.req.QueryInterface(Components.interfaces.nsIJSXMLHttpRequest);
  2535.     this.req.open('GET', aUrl, true);
  2536.     var req = this.req;
  2537.     this.req.onreadystatechange = function (aEvt) {
  2538.       if (req.readyState == 4) {
  2539.         try {
  2540.           if (req.status/100 == 2) {
  2541.              try {
  2542.               //inst._logger.info(req.responseText);
  2543.               var rsp = req.responseXML.getElementsByTagName("rsp")[0];
  2544.               var stat = rsp.getAttribute("stat");
  2545.               if (stat !="ok") {
  2546.                 var err = req.responseXML.getElementsByTagName("err")[0];
  2547.                 var error= inst.getError('SERVICE_ERROR', req.responseXML, null);
  2548.  
  2549.                 aListener.onError(error);
  2550.               }
  2551.               else {
  2552.                 aListener.onResult(req.responseXML);
  2553.               }
  2554.             } catch (ex) {
  2555.               // error parsing xml
  2556.               inst._logger.error(ex);
  2557.               aListener.onError(inst.getError('SERVICE_ERROR', null, null));
  2558.             }
  2559.           }
  2560.           else {
  2561.             //  http errors
  2562.             aListener.onError(inst.getError("HTTP_ERROR", null, req.status));
  2563.           }
  2564.         } catch(e) {
  2565.           // XMHTTPERROR (connection lost)
  2566.           inst._logger.info(e);
  2567.           aListener.onError(inst.getError('HTTP_ERROR',null, "9001"));
  2568.         }
  2569.       }
  2570.     }
  2571.     this.req.send(null);
  2572.   };
  2573.   this.getError = function(aErrorType, aXML, aHTTPErrorCode) {
  2574.     var error = Components.classes[FLOCK_ERROR_CONTRACTID].createInstance(flockIError);
  2575.     if  (aErrorType == "HTTP_ERROR") {
  2576.       error.errorCode = aHTTPErrorCode;
  2577.     } else if (aErrorType == "SERVICE_ERROR") {
  2578.       var errorCode;
  2579.       var errorMessage;
  2580.       var serviceErrorMessage;
  2581.       try {
  2582.         errorCode = aXML.getElementsByTagName("err")[0].getAttribute('code');
  2583.         serviceErrorMessage = aXML.getElementsByTagName("err")[0].getAttribute('msg');
  2584.       } catch (ex) {
  2585.         errorCode = "999" // in case the error xml is invalid
  2586.       }
  2587.  
  2588.       switch (errorCode) {
  2589.         case "1":
  2590.           error.errorCode = error.PHOTOSERVICE_INVALID_USER;
  2591.         break;
  2592.  
  2593.         case "3":
  2594.           error.errorCode = error.PHOTOSERVICE_UPLOAD_ERROR;
  2595.         break;
  2596.  
  2597.         case "4":
  2598.           error.errorCode = error.PHOTOSERVICE_FILE_IS_OVER_SIZE_LIMIT;
  2599.         break;
  2600.  
  2601.         case "5":
  2602.           error.errorCode = error.PHOTOSERVICE_INVALID_UPLOAD_FILE;
  2603.         break;
  2604.  
  2605.         case "6":
  2606.           error.errorCode = error.PHOTOSERVICE_BANDWIDTH_REACHED;
  2607.         break;
  2608.  
  2609.         case "10":
  2610.  
  2611.         break;
  2612.  
  2613.         case "98":
  2614.           error.errorCode = error.PHOTOSERVICE_LOGIN_FAILED;
  2615.         break;
  2616.  
  2617.         case "99":
  2618.           error.errorCode = error.PHOTOSERVICE_USER_NOT_LOGGED_IN;
  2619.         break;
  2620.  
  2621.         case "100":
  2622.           error.errorCode = error.PHOTOSERVICE_INVALID_API_KEY;
  2623.           break;
  2624.  
  2625.         case "105":
  2626.           error.errorCode = error.PHOTOSERVICE_UNAVAILABLE;
  2627.         break;
  2628.  
  2629.         case "999":
  2630.           error.errorCode = error.PHOTOSERVICE_UNKNOWN_ERROR;
  2631.         break;
  2632.  
  2633.         default:
  2634.           error.errorCode = error.PHOTOSERVICE_UNKNOWN_ERROR;
  2635.           error.serviceErrorString = serviceErrorMessage;
  2636.         break;
  2637.       }
  2638.     }
  2639.     //inst._logger.info('<<<<<<<<<<<<<<'  + error.errorString + '\n');
  2640.     return error;
  2641.   };
  2642.   this.getAuthUrl = function(aFrob, aPerms) {
  2643.     var api_key = this.api_key;
  2644.     var params = {
  2645.       api_key: api_key,
  2646.       perms: aPerms,
  2647.       frob: aFrob
  2648.     }
  2649.  
  2650.     var paramString = this.getParamString(params, true);
  2651.     return this.auth_endpoint + "?" + paramString;
  2652.   };
  2653.   this.getParamString = function(aParams, aNoMethod) {
  2654.     aParams = this.appendSignature(aParams);
  2655.     var rval = "";
  2656.     if (!aNoMethod) rval += "method=" + aParams.method + "&";
  2657.  
  2658.     var count = 0;
  2659.     for (var p in aParams) {
  2660.       if (p.match(/method/)) continue;
  2661.  
  2662.       if (count++ != 0) rval += "&";
  2663.       rval += encodeURIComponent(p) + "=" + encodeURIComponent(aParams[p]);
  2664.     }
  2665.     return rval;
  2666.   };
  2667.   this.appendSignature = function(aParams) {
  2668.     var keys = [];
  2669.     for (var p in aParams) {
  2670.       keys.push(p);
  2671.     }
  2672.     keys.sort();
  2673.     var preHash = this.api_secret;
  2674.     for (var i = 0; i < keys.length; ++i) {
  2675.       preHash += keys[i] + aParams[keys[i]];
  2676.     }
  2677.     inst._logger.info("preHash " + preHash);
  2678.  
  2679.     var converter =
  2680.       Components.classes["@mozilla.org/intl/scriptableunicodeconverter"]
  2681.                 .createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
  2682.     converter.charset = "UTF-8";
  2683.  
  2684.     var inputStream = converter.convertToInputStream(preHash);
  2685.     aParams.api_sig = FlockCryptoHash.md5Stream(inputStream);
  2686.     return aParams;
  2687.   };
  2688. }
  2689.  
  2690. FlickrAPI.prototype = {};
  2691.  
  2692. // ========== END FlickrAPI class ==========
  2693.  
  2694.  
  2695.  
  2696. // ============================================
  2697. // ========== BEGIN FlickrUser class ==========
  2698. // ============================================
  2699.  
  2700. function FlickrUser() {
  2701.   this.token = "";
  2702.   this.perms = "";
  2703.   this.nsid = "";
  2704.   this.id = "";
  2705.   this.username = "";
  2706.   this.fullname = "";
  2707. }
  2708.  
  2709. FlickrUser.prototype = {};
  2710.  
  2711. // ========== END FlickrUser class =========
  2712.  
  2713.  
  2714.  
  2715. // ===============================================
  2716. // ========== BEGIN flickrAccount class ==========
  2717. // ===============================================
  2718.  
  2719. function flickrAccount()
  2720. {
  2721.   this._logger = Components.classes['@flock.com/logger;1'].createInstance(Components.interfaces.flockILogger);
  2722.   this._logger.init('flickrAccount');
  2723.   this._logger.info('Created Flickr Account Object');
  2724.  
  2725.   this.acUtils = Components.classes["@flock.com/account-utils;1"]
  2726.                            .getService(Components.interfaces.flockIAccountUtils);
  2727.   this.svc = Components.classes[FLICKR_CONTRACTID]
  2728.                        .getService(Components.interfaces.flockIMediaWebService)
  2729.                        .QueryInterface(Components.interfaces.flockIWebService);
  2730.   if (!gFlickrAPI) {
  2731.     gFlickrAPI = new FlickrAPI();
  2732.   }
  2733.   this.api = gFlickrAPI;
  2734.   this.api.svc = this.svc;
  2735.  
  2736.   this._coop = Components.classes["@flock.com/singleton;1"]
  2737.                          .getService(Components.interfaces.flockISingleton)
  2738.                          .getSingleton("chrome://flock/content/common/load-faves-coop.js")
  2739.                          .wrappedJSObject;
  2740.   this.webDetective = Cc["@flock.com/web-detective;1"]
  2741.                       .getService(Ci.flockIWebDetective);
  2742.   this._ctk = {
  2743.     interfaces: [
  2744.       "nsISupports",
  2745.       "flockIWebServiceAccount",
  2746.       "flockISocialWebServiceAccount",
  2747.       "flockIMediaWebServiceAccount",
  2748.       "flockIMediaUploadAccount",
  2749.       "flockIFlickrAccount"
  2750.     ]
  2751.   };
  2752.   getCompTK().addAllInterfaces(this);
  2753. }
  2754.  
  2755.  
  2756. // BEGIN flockIWebServiceAccount interface
  2757. flickrAccount.prototype.urn = null;
  2758.  
  2759. flickrAccount.prototype.login =
  2760. function flickrAccount_login(aListener)
  2761. {
  2762.   this._logger.info("{flockIWebServiceAccount}.login()");
  2763.  
  2764.   var inst = this;
  2765.   var myListener = {
  2766.     onSuccess: function (aSubject, aTopic) {
  2767.       inst.acUtils.ensureOnlyAuthenticatedAccount(inst.urn);
  2768.       // force refresh on login
  2769.       var pollerSvc = Cc["@flock.com/poller-service;1"]
  2770.                       .getService(Ci.flockIPollerService);
  2771.       pollerSvc.forceRefresh(inst.urn);
  2772.       if (aListener) {
  2773.         aListener.onSuccess(null, "");
  2774.       }
  2775.     },
  2776.     onError: function (aError) {
  2777.       if (aListener) {
  2778.         aListener.onError(aError);
  2779.       }
  2780.     }
  2781.   }
  2782.   this.api.logout();
  2783.   this.acUtils.markAllAccountsAsLoggedOut(FLICKR_CONTRACTID);
  2784.  
  2785.   this.api.login(this.urn, myListener);
  2786. }
  2787.  
  2788. flickrAccount.prototype.logout =
  2789. function flickrAccount_logout(aListener)
  2790. {
  2791.   this._logger.info("{flockIWebServiceAccount}.logout()");
  2792.   var acctCoopObj = this._coop.get(this.urn);
  2793.   if (acctCoopObj.isAuthenticated) {
  2794.     acctCoopObj.isAuthenticated = false;
  2795.     this.svc.logout();
  2796.   }
  2797. }
  2798.  
  2799. flickrAccount.prototype.activate =
  2800. function flickrAccount_activate(aListener)
  2801. {
  2802.   this._logger.info("{flockIWebServiceAccount}.activate()");
  2803.   var acctCoopObj = this._coop.get(this.urn);
  2804.   var inst = this;
  2805.   var listener = {
  2806.     onSuccess: function (aSubject, aTopic) {
  2807.       if (aListener) aListener.onSuccess(inst, "accountAuthorized");
  2808.       acctCoopObj.isPollable = true;
  2809.       inst.acUtils.ensureOnlyAuthenticatedAccount(inst.urn);
  2810.     },
  2811.     onError: function (aError) {
  2812.       inst._logger.info( "Flickr account activation ERROR: " +
  2813.                          (aError ? aError.errorString : "No details. :("));
  2814.       acctCoopObj.isAuthenticated = false;
  2815.     }
  2816.   };
  2817.   this.login(listener);
  2818.   // I'm going to jump the gun a bit here and assume that the authentication is
  2819.   // going to succeed.  If it fails, it will be caught by the listener.  But at
  2820.   // least this will prevent any further attempts to authenticate until this
  2821.   // attempt completes.
  2822.   acctCoopObj.isAuthenticated = true;
  2823. }
  2824.  
  2825. flickrAccount.prototype.keep =
  2826. function flickrAccount_keep()
  2827. {
  2828.   this._logger.info(".keep(): "+this.urn);
  2829.   var c_acct = this._coop.get(this.urn);
  2830.   c_acct.isTransient = false;
  2831.   this.acUtils.makeTempPasswordPermanent(this.svc.urn + ":"
  2832.                                          + c_acct.accountId);
  2833.  
  2834.   // Subscribe to the recent activity RSS feed for this account
  2835.   var feedMgr = Cc["@flock.com/feed-manager;1"]
  2836.                 .getService(Ci.flockIFeedManager);
  2837.   var inst = this;
  2838.   var feedListener = {
  2839.     onGetFeedComplete: function keep_feed_complete(aFeed) {
  2840.       feedMgr.getFeedContext("news").getRoot().subscribeFeed(aFeed);
  2841.       Cc["@flock.com/metrics-service;1"]
  2842.         .getService(Ci.flockIMetricsService)
  2843.         .report("FeedsSidebar-AddFeed",  "FlickrAccountKeep");
  2844.     },
  2845.     onError: function keep_feed_error(aError) {
  2846.       inst._logger.debug("There was a problem subscribing to the recent "
  2847.                          + "activity feed for Flickr account "
  2848.                          + c_acct.accountId);
  2849.     }
  2850.   };
  2851.   try {
  2852.     var feedURI = Cc["@mozilla.org/network/standard-url;1"]
  2853.                   .createInstance(Ci.nsIURI);
  2854.     feedURI.spec = gStrings["commentsreceivedRSS"]
  2855.                    .replace("%accountid%", c_acct.accountId);
  2856.     feedMgr.getFeed(feedURI, feedListener);
  2857.   } catch (ex) {
  2858.     this._logger.debug("There was an error subscribing to the recent "
  2859.                        + "activity feed for Flickr account "
  2860.                        + c_acct.accountId);
  2861.   }
  2862. }
  2863. // END flockIWebServiceAccount interface
  2864.  
  2865.  
  2866. // BEGIN flockISocialWebServiceAccount interface
  2867. flickrAccount.prototype.hasFriendActions = true;
  2868. flickrAccount.prototype.isStatusSupported = false;
  2869. flickrAccount.prototype.isStatusEditable  = false;
  2870. flickrAccount.prototype.isPostLinkSupported = false;
  2871. flickrAccount.prototype.isMyMediaFavoritesSupported = false;
  2872.  
  2873. flickrAccount.prototype.setStatus =
  2874. function flickrAccount_setStatus(aStatusMessage, aListener)
  2875. {
  2876.   this._logger.info("{flockISocialWebServiceAccount}.setStatus('"+aStatusMessage+"',"+
  2877.                                                               "'"+aListener+"')");
  2878. }
  2879.  
  2880. flickrAccount.prototype.getEditableStatus =
  2881. function flickrAccount_getEditableStatus()
  2882. {
  2883.   this._logger.info("{flockISocialWebServiceAccount}.getEditableStatus()");
  2884.   return "";
  2885. }
  2886.  
  2887. flickrAccount.prototype.formatStatusForDisplay =
  2888. function flickrAccount_formatStatusForDisplay(aStatusMessage)
  2889. {
  2890.   return "";
  2891. }
  2892.  
  2893. flickrAccount.prototype.markAllMeNotificationsSeen =
  2894. function flickrAccount_markAllMeNotificationsSeen(aType) {
  2895.   this._logger.debug(".markAllMeNotificationsSeen('" + aType + "')");
  2896.   var c_acct = this._coop.get(this.urn);
  2897.   switch (aType) {
  2898.     case "meMessages":
  2899.       c_acct.accountMessages = 0;
  2900.       break;
  2901.     case "meCommentActivity":
  2902.       if (c_acct.flickr_comments > 0) {
  2903.         c_acct.lastUpdateDate = new Date();
  2904.         c_acct.flickr_comments = 0;
  2905.         c_acct.flickr_comments_timespan = 0;
  2906.       }
  2907.       break;
  2908.       
  2909.     default:
  2910.       break;
  2911.   }
  2912. }
  2913.  
  2914. flickrAccount.prototype.getMeNotifications =
  2915. function flickrAccount_getMeNotifications()
  2916. {
  2917.   this._logger.info(".getMeNotifications()");
  2918.  
  2919.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  2920.             .getService(Ci.nsIStringBundleService);
  2921.   var bundle = sbs.createBundle(FLICKR_STRING_BUNDLE);
  2922.  
  2923.   var noties = [];
  2924.   var inst = this;
  2925.   function _addNotie(aType, aCount, aUrl) {
  2926.     var stringName = "flock.flickr.noties."
  2927.                    + aType + "."
  2928.                    + ((parseInt(aCount) <= 0) ? "none" : "some");
  2929.     noties.push({
  2930.       class: aType,
  2931.       tooltip: bundle.GetStringFromName(stringName),
  2932.       metricsName: aType,
  2933.       count: aCount,
  2934.       URL: aUrl
  2935.     });
  2936.   }
  2937.   var c_acct = this._coop.get(this.urn);
  2938.   var url = this.webDetective.getString("flickr", "meMessages_URL", "");
  2939.   _addNotie("meMessages", c_acct.accountMessages, url);
  2940.   url = this.webDetective.getString("flickr", "meCommentActivity_URL", "")
  2941.             .replace("%timespan%", c_acct.flickr_comments_timespan);
  2942.   _addNotie("meCommentActivity", c_acct.flickr_comments, url);
  2943.   return JSON.toString(noties);
  2944. }
  2945.  
  2946. flickrAccount.prototype.getFriendActions =
  2947. function flickrAccount_getFriendActions(aFriendURN)
  2948. {
  2949.   this._logger.info(".getFriendActions('" + aFriendURN + "')");
  2950.  
  2951.   var actionNames = ["friendMessage",
  2952.                      "friendViewProfile",
  2953.                      "friendShareFlock"];
  2954.  
  2955.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  2956.             .getService(Ci.nsIStringBundleService);
  2957.   var bundle = sbs.createBundle(FLICKR_STRING_BUNDLE);
  2958.  
  2959.   var actions = [];
  2960.   var c_friend = this._coop.get(aFriendURN);
  2961.   if (c_friend) {
  2962.     var c_acct = this._coop.get(this.urn);
  2963.     for each (var i in actionNames) {
  2964.       actions.push({
  2965.         label: bundle.GetStringFromName("flock.flickr.actions." + i),
  2966.         class: i,
  2967.         spec: this.webDetective.getString("flickr", i, "")
  2968.                   .replace("%accountid%", c_acct.accountId)
  2969.                   .replace("%friendid%", c_friend.accountId)
  2970.       });
  2971.     }
  2972.   }
  2973.   return JSON.toString(actions);
  2974. }
  2975.  
  2976. flickrAccount.prototype.getSharingAction =
  2977. function flickrAccount_getSharingAction(aFriendURN, aTransferable)
  2978. {
  2979.   this._logger.info(".getSharingAction('" + aFriendURN + "')");
  2980.  
  2981.   var sharingAction = "";
  2982.   var c_friend = this._coop.get(aFriendURN);
  2983.   if (c_friend) {
  2984.     // Flavors we want to support, in order of preference
  2985.     var flavors = ["text/x-flock-media",
  2986.                    "text/x-moz-url",
  2987.                    "text/unicode",
  2988.                    "text/html"];
  2989.  
  2990.     var message = Cc[FLOCK_RDDS_CONTRACTID]
  2991.                   .getService(Ci.flockIRichDNDService)
  2992.                   .getMessageFromTransferable(aTransferable,
  2993.                                               flavors.length,
  2994.                                               flavors);
  2995.     if (message.body) {
  2996.       sharingAction = this.webDetective.getString("flickr", "shareAction", "")
  2997.                           .replace("%friendid%", c_friend.accountId);
  2998.     }
  2999.   }
  3000.   this._logger.info("sharingAction = "+sharingAction);
  3001.   return sharingAction;
  3002. }
  3003.  
  3004. flickrAccount.prototype.getProfileURLForFriend = 
  3005. function flickrAccount_getProfileURLForFriend(aFriendURN)
  3006. {
  3007.   this._logger.info(".getProfileURLForFriend('" + aFriendURN + "')");
  3008.  
  3009.   var url = "";
  3010.   var c_friend = this._coop.get(aFriendURN);
  3011.   if (c_friend) {
  3012.     url = this.webDetective.getString("flickr", "friendprofile", "")
  3013.                            .replace("%accountid%", c_friend.accountId);
  3014.   }
  3015.  
  3016.   return url;
  3017. }
  3018.  
  3019. flickrAccount.prototype.getPostLinkAction =
  3020. function flickrAccount_getPostLinkAction(aTransferable)
  3021. {
  3022.   return "";
  3023. }
  3024. // END flockISocialWebServiceAccount interface
  3025.  
  3026.  
  3027. // BEGIN flockIFlickrAccount interface
  3028. flickrAccount.prototype.shareFlock =
  3029. function flickrAccount_shareFlock(aFriendURN) 
  3030. {
  3031.   this._logger.info(".shareFlock('" + aFriendURN + "')");
  3032.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  3033.               .getService(Ci.nsIStringBundleService);
  3034.   var bundle = sbs.createBundle(FLICKR_STRING_BUNDLE);
  3035.   var body = bundle.GetStringFromName("flock.flickr.friendShareFlock.message");
  3036.   var subj = bundle.GetStringFromName("flock.flickr.friendShareFlock.subject");
  3037.   this._composeMessage(aFriendURN, subj, body, false);
  3038. }
  3039.  
  3040. flickrAccount.prototype.flickrMail =
  3041. function flickrAccount_flickrMail(aFriendURN, aTransferable)
  3042. {
  3043.   this._logger.info(".flickrMail('" + aFriendURN + "')");
  3044.  
  3045.   var flavors = ["text/x-flock-media",
  3046.                  "text/x-moz-url",
  3047.                  "text/unicode",
  3048.                  "text/html"];
  3049.  
  3050.   var message = Cc[FLOCK_RDDS_CONTRACTID]
  3051.                   .getService(Ci.flockIRichDNDService)
  3052.                   .getMessageFromTransferable(aTransferable,
  3053.                                               flavors.length,
  3054.                                               flavors);
  3055.   if (message.body) {
  3056.     this._composeMessage(aFriendURN, message.subject, message.body, true);
  3057.   }
  3058. }
  3059.  
  3060. flickrAccount.prototype._composeMessage =
  3061. function flickrAccount__composeMessage(aFriendURN, aSubject, aBody, addBreadCrumb)
  3062. {
  3063.   var body = aBody;
  3064.   var subject = aSubject;
  3065.   var c_friend = this._coop.get(aFriendURN);
  3066.   var url = this.webDetective.getString("flickr", "flickrmail_URL", "")
  3067.                              .replace("%friendid%", c_friend.accountId);
  3068.   var wm = Cc["@mozilla.org/appshell/window-mediator;1"]
  3069.              .getService(Ci.nsIWindowMediator);
  3070.   var win = wm.getMostRecentWindow("navigator:browser");
  3071.   if (win) {
  3072.    var browser = win.getBrowser();
  3073.    var newTab = browser.loadOneTab(url, null, null, null, false, false);
  3074.    var obs = Cc["@mozilla.org/observer-service;1"]
  3075.              .getService(Ci.nsIObserverService);
  3076.    var inst = this;
  3077.    var observer = {
  3078.      observe: function openSendMessageTabForFill_observer(aContent,
  3079.                                                           aTopic,
  3080.                                                           aContextUrl)
  3081.      {
  3082.        var contentWindow = newTab.linkedBrowser.docShell
  3083.                                  .QueryInterface(Ci.nsIInterfaceRequestor)
  3084.                                  .getInterface(Ci.nsIDOMWindow);
  3085.        function insertContent(aWebDicString, aMessage) {
  3086.          var xpathquery = inst.webDetective.getString("flickr", aWebDicString, "");
  3087.          var doc = contentWindow.document;
  3088.          var formItems = doc.evaluate(xpathquery, doc, null,
  3089.                                       Ci.nsIDOMXPathResult.ANY_TYPE, null);
  3090.          if (formItems) {
  3091.            var formItem = formItems.iterateNext();
  3092.            if (formItem.hasAttribute("value")) {
  3093.              formItem.setAttribute("value", aMessage);
  3094.            } else {
  3095.              var textNode = doc.createTextNode(aMessage);
  3096.              formItem.appendChild(textNode);
  3097.              inst._logger.info("aMessage " + aMessage);
  3098.            }
  3099.          }
  3100.        }
  3101.        if (contentWindow == aContent) {
  3102.          obs.removeObserver(this, "EndDocumentLoad");
  3103.          insertContent("flickrmail_subjectXPath", subject);
  3104.          if(addBreadCrumb)
  3105.          {
  3106.             // Add breadcrumb to message body
  3107.             var breadcrumb = Cc[FLOCK_RDDS_CONTRACTID]
  3108.                                .getService(Ci.flockIRichDNDService)
  3109.                                .getBreadcrumb("plain");
  3110.            if (breadcrumb) {
  3111.              body += breadcrumb;
  3112.            }
  3113.         }
  3114.          insertContent("flickrmail_bodyXPath", body);
  3115.        }
  3116.      }
  3117.    };
  3118.    obs.addObserver(observer, "EndDocumentLoad", false);
  3119.   }
  3120. }
  3121. // END flockIFlickrAccount interface
  3122.  
  3123. // ========== END flickrAccount class ==========
  3124.